jerkjs 2.1.7 → 2.3.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/query/MariaDBAdapter.js

@@ -0,0 +1,78 @@
+/**
+ * Adaptador de MariaDB para el QueryBuilder
+ * MariaDBAdapter.js
+ * 
+ * Este adaptador simplemente ejecuta las consultas SQL construidas por el QueryBuilder
+ */
+
+const mariadb = require('mariadb');
+
+class MariaDBAdapter {
+  /**
+   * Constructor del adaptador MariaDB
+   * @param {Object} options - Opciones de configuración
+   */
+  constructor(options = {}) {
+    // Configuración de la conexión a la base de datos
+    this.dbConfig = {
+      host: options.host || 'localhost',
+      user: options.user || 'root',
+      password: options.password || '',
+      database: options.database || 'otrack_db',
+      waitForConnections: options.waitForConnections !== false,
+      connectionLimit: options.connectionLimit || 10,
+      queueLimit: options.queueLimit || 0,
+      acquireTimeout: options.acquireTimeout || 60000,
+      timeout: options.timeout || 60000,
+      ...options
+    };
+
+    // Crear pool de conexiones
+    this.pool = mariadb.createPool(this.dbConfig);
+  }
+
+  /**
+   * Método para ejecutar una consulta SQL
+   * @param {string} sql - Consulta SQL construida por el QueryBuilder
+   * @param {Array} params - Parámetros de la consulta
+   * @returns {Promise<Object>} - Resultado de la consulta
+   */
+  async query(sql, params = []) {
+    const connection = await this.pool.getConnection();
+    try {
+      return await connection.query(sql, params);
+    } catch (error) {
+      throw error;
+    } finally {
+      connection.release();
+    }
+  }
+
+  /**
+   * Método para cerrar la conexión
+   */
+  async close() {
+    try {
+      await this.pool.end();
+      console.log('Conexión a MariaDB cerrada correctamente');
+    } catch (error) {
+      console.error('Error al cerrar la conexión a MariaDB:', error.message);
+    }
+  }
+
+  /**
+   * Método para verificar si el adaptador está conectado
+   * @returns {Promise<boolean>} - Verdadero si está conectado
+   */
+  async isConnected() {
+    try {
+      const connection = await this.pool.getConnection();
+      connection.release();
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+}
+
+module.exports = MariaDBAdapter;

package/lib/query/consoleAdapter.js

@@ -0,0 +1,184 @@
+/**
+ * Adaptador de ejemplo para mostrar consultas SQL por consola
+ * ConsoleAdapter.js
+ */
+
+class ConsoleAdapter {
+  constructor(options = {}) {
+    this.options = options;
+    this.queriesExecuted = 0;
+  }
+
+  /**
+   * Método para ejecutar una consulta
+   * @param {string} sql - Consulta SQL
+   * @param {Array} params - Parámetros de la consulta
+   * @returns {Promise<Object>} - Resultado simulado
+   */
+  async query(sql, params = []) {
+    this.queriesExecuted++;
+    
+    console.log(`\n--- CONSULTA #${this.queriesExecuted} ---`);
+    console.log(`SQL: ${sql}`);
+    console.log(`Parámetros:`, params);
+    console.log('--- FIN CONSULTA ---\n');
+    
+    // Simular un resultado dependiendo del tipo de consulta
+    if (sql.trim().toUpperCase().startsWith('SELECT')) {
+      // Para consultas SELECT, devolver un array vacío o con datos simulados
+      return [];
+    } else if (sql.trim().toUpperCase().startsWith('INSERT')) {
+      // Para INSERT, simular un ID insertado
+      return { insertId: Math.floor(Math.random() * 10000), affectedRows: 1 };
+    } else if (sql.trim().toUpperCase().startsWith('UPDATE') || sql.trim().toUpperCase().startsWith('DELETE')) {
+      // Para UPDATE/DELETE, simular filas afectadas
+      return { affectedRows: Math.floor(Math.random() * 5) + 1 };
+    } else {
+      // Para otros tipos de consulta, devolver un objeto vacío
+      return {};
+    }
+  }
+
+  /**
+   * Método para crear un registro
+   * @param {string} tableName - Nombre de la tabla
+   * @param {Object} data - Datos a insertar
+   * @returns {Promise<Object>} - Resultado simulado
+   */
+  async create(tableName, data) {
+    const columns = Object.keys(data).join(', ');
+    const placeholders = Object.keys(data).map(() => '?').join(', ');
+    const sql = `INSERT INTO \`${tableName}\` (${columns}) VALUES (${placeholders})`;
+    const params = Object.values(data);
+    
+    return await this.query(sql, params);
+  }
+
+  /**
+   * 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>} - Resultados simulados
+   */
+  async find(tableName, conditions, options = {}) {
+    let sql = `SELECT * FROM \`${tableName}\``;
+    const params = [];
+    
+    if (conditions && Object.keys(conditions).length > 0) {
+      const conditionsList = [];
+      for (const [key, value] of Object.entries(conditions)) {
+        if (value !== undefined && value !== null) {
+          conditionsList.push(`${key} = ?`);
+          params.push(value);
+        }
+      }
+      if (conditionsList.length > 0) {
+        sql += ' WHERE ' + conditionsList.join(' AND ');
+      }
+    }
+    
+    return await this.query(sql, params);
+  }
+
+  /**
+   * 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>} - Resultado simulado o null
+   */
+  async findOne(tableName, conditions, options = {}) {
+    const results = await this.find(tableName, conditions, { ...options, limit: 1 });
+    return results.length > 0 ? results[0] : null;
+  }
+
+  /**
+   * 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>} - Número de filas afectadas simuladas
+   */
+  async update(tableName, conditions, data) {
+    const dataEntries = Object.entries(data);
+    if (dataEntries.length === 0) {
+      return 0;
+    }
+
+    const setClause = dataEntries.map(([key]) => `${key} = ?`).join(', ');
+    const params = dataEntries.map(([, value]) => value);
+
+    const whereClause = [];
+    for (const [key, value] of Object.entries(conditions)) {
+      if (value !== undefined && value !== null) {
+        whereClause.push(`${key} = ?`);
+        params.push(value);
+      }
+    }
+
+    let sql = `UPDATE \`${tableName}\` SET ${setClause}`;
+    if (whereClause.length > 0) {
+      sql += ' WHERE ' + whereClause.join(' AND ');
+    }
+
+    const result = await this.query(sql, params);
+    return result.affectedRows || 0;
+  }
+
+  /**
+   * Método para eliminar registros
+   * @param {string} tableName - Nombre de la tabla
+   * @param {Object} conditions - Condiciones para seleccionar registros
+   * @returns {Promise<number>} - Número de filas afectadas simuladas
+   */
+  async delete(tableName, conditions) {
+    let sql = `DELETE FROM \`${tableName}\``;
+    const params = [];
+
+    if (conditions && Object.keys(conditions).length > 0) {
+      const conditionsList = [];
+      for (const [key, value] of Object.entries(conditions)) {
+        if (value !== undefined && value !== null) {
+          conditionsList.push(`${key} = ?`);
+          params.push(value);
+        }
+      }
+      if (conditionsList.length > 0) {
+        sql += ' WHERE ' + conditionsList.join(' AND ');
+      }
+    }
+
+    const result = await this.query(sql, params);
+    return result.affectedRows || 0;
+  }
+
+  /**
+   * Método para contar registros
+   * @param {string} tableName - Nombre de la tabla
+   * @param {Object} conditions - Condiciones de conteo
+   * @returns {Promise<number>} - Número simulado de registros
+   */
+  async count(tableName, conditions) {
+    let sql = `SELECT COUNT(*) as total FROM \`${tableName}\``;
+    const params = [];
+
+    if (conditions && Object.keys(conditions).length > 0) {
+      const conditionsList = [];
+      for (const [key, value] of Object.entries(conditions)) {
+        if (value !== undefined && value !== null) {
+          conditionsList.push(`${key} = ?`);
+          params.push(value);
+        }
+      }
+      if (conditionsList.length > 0) {
+        sql += ' WHERE ' + conditionsList.join(' AND ');
+      }
+    }
+
+    const result = await this.query(sql, params);
+    return result[0] ? result[0].total : 0;
+  }
+}
+
+module.exports = ConsoleAdapter;