jerkjs 2.2.0 → 2.3.0

package/lib/query/queryBuilder.js

@@ -0,0 +1,953 @@
+/**
+ * QueryBuilder para MariaDB compatible con el framework JERK
+ * Implementación del componente query/queryBuilder.js
+ * Proporciona una interfaz fluida para construir consultas SQL complejas
+ */
+
+class QueryBuilder {
+  /**
+   * Constructor del QueryBuilder
+   * @param {Object} adapter - Adaptador de base de datos (debería ser MariaDBAdapter)
+   * @param {string} tableName - Nombre de la tabla (opcional)
+   */
+  constructor(adapter = null, tableName = null) {
+    this.adapter = adapter;
+    this.tableName = tableName;
+    
+    // Inicializar componentes de la consulta
+    this.selectFields = [];
+    this.whereConditions = [];
+    this.joins = [];
+    this.groupByFields = [];
+    this.havingConditions = [];
+    this.orderByFields = [];
+    this.limitValue = null;
+    this.offsetValue = null;
+    this.unionQueries = [];
+    
+    // Parámetros para la consulta
+    this.parameters = [];
+  }
+
+  /**
+   * Establece el adaptador de base de datos para el QueryBuilder
+   * @param {Object} adapter - Adaptador de base de datos
+   * @returns {QueryBuilder} - Instancia del QueryBuilder para encadenamiento
+   */
+  setAdapter(adapter) {
+    this.adapter = adapter;
+    return this;
+  }
+
+  /**
+   * Establece la tabla para la consulta
+   * @param {string} tableName - Nombre de la tabla
+   * @returns {QueryBuilder} - Instancia del QueryBuilder para encadenamiento
+   */
+  table(tableName) {
+    this.tableName = tableName;
+    return this;
+  }
+
+  /**
+   * Especifica los campos a seleccionar
+   * @param {...string} fields - Campos a seleccionar
+   * @returns {QueryBuilder} - Instancia del QueryBuilder para encadenamiento
+   */
+  select(...fields) {
+    if (fields.length === 1 && Array.isArray(fields[0])) {
+      this.selectFields = [...this.selectFields, ...fields[0]];
+    } else {
+      this.selectFields = [...this.selectFields, ...fields];
+    }
+    return this;
+  }
+
+  /**
+   * Agrega una condición WHERE
+   * @param {string|Object|Function} field - Campo, objeto de condiciones o función para condiciones complejas
+   * @param {string} [operator] - Operador (opcional)
+   * @param {*} [value] - Valor (opcional)
+   * @returns {QueryBuilder} - Instancia del QueryBuilder para encadenamiento
+   */
+  where(field, operator = null, value = null) {
+    // Si se pasa una función, manejarla como condición compleja
+    if (typeof field === 'function') {
+      // Ejecutar la función pasándole una instancia del QueryBuilder para construir condiciones anidadas
+      const subQueryBuilder = new QueryBuilder(this.adapter, this.tableName);
+      field(subQueryBuilder);
+
+      // Copiar las condiciones del subquery builder
+      this.whereConditions.push(...subQueryBuilder.whereConditions);
+      this.parameters.push(...subQueryBuilder.parameters);
+
+      return this;
+    }
+
+    if (typeof field === 'object') {
+      // Si se pasa un objeto, agregar múltiples condiciones AND
+      for (const [key, val] of Object.entries(field)) {
+        this.where(key, '=', val);
+      }
+      return this;
+    }
+
+    // Si solo se pasan dos argumentos, asumir que es campo = valor
+    if (arguments.length === 2) {
+      value = operator;
+      operator = '=';
+    }
+
+    // Escapar el campo para prevenir inyección SQL
+    const escapedField = this.escapeField(field);
+
+    this.whereConditions.push({
+      field: escapedField,
+      operator: operator,
+      value: '?',
+      condition: 'AND'
+    });
+
+    this.parameters.push(value);
+
+    return this;
+  }
+
+  /**
+   * Agrega una condición WHERE OR
+   * @param {string|Object} field - Campo o objeto de condiciones
+   * @param {string} [operator] - Operador (opcional)
+   * @param {*} [value] - Valor (opcional)
+   * @returns {QueryBuilder} - Instancia del QueryBuilder para encadenamiento
+   */
+  orWhere(field, operator = null, value = null) {
+    if (typeof field === 'object') {
+      // Si se pasa un objeto, agregar múltiples condiciones OR
+      for (const [key, val] of Object.entries(field)) {
+        this.orWhere(key, '=', val);
+      }
+      return this;
+    }
+
+    // Si solo se pasan dos argumentos, asumir que es campo = valor
+    if (arguments.length === 2) {
+      value = operator;
+      operator = '=';
+    }
+
+    // Escapar el campo para prevenir inyección SQL
+    const escapedField = this.escapeField(field);
+    
+    this.whereConditions.push({
+      field: escapedField,
+      operator: operator,
+      value: '?',
+      condition: 'OR'
+    });
+
+    this.parameters.push(value);
+    
+    return this;
+  }
+
+  /**
+   * Agrega una condición WHERE IN
+   * @param {string} field - Campo
+   * @param {Array} values - Valores
+   * @returns {QueryBuilder} - Instancia del QueryBuilder para encadenamiento
+   */
+  whereIn(field, values) {
+    if (!Array.isArray(values)) {
+      throw new Error('Los valores para whereIn deben ser un array');
+    }
+
+    const escapedField = this.escapeField(field);
+    const placeholders = values.map(() => '?').join(', ');
+    
+    this.whereConditions.push({
+      field: escapedField,
+      operator: 'IN',
+      value: `(${placeholders})`,
+      condition: 'AND'
+    });
+    
+    this.parameters.push(...values);
+    
+    return this;
+  }
+
+  /**
+   * Agrega una condición WHERE NOT IN
+   * @param {string} field - Campo
+   * @param {Array} values - Valores
+   * @returns {QueryBuilder} - Instancia del QueryBuilder para encadenamiento
+   */
+  whereNotIn(field, values) {
+    if (!Array.isArray(values)) {
+      throw new Error('Los valores para whereNotIn deben ser un array');
+    }
+
+    const escapedField = this.escapeField(field);
+    const placeholders = values.map(() => '?').join(', ');
+    
+    this.whereConditions.push({
+      field: escapedField,
+      operator: 'NOT IN',
+      value: `(${placeholders})`,
+      condition: 'AND'
+    });
+    
+    this.parameters.push(...values);
+    
+    return this;
+  }
+
+  /**
+   * Agrega una condición WHERE BETWEEN
+   * @param {string} field - Campo
+   * @param {*} minValue - Valor mínimo
+   * @param {*} maxValue - Valor máximo
+   * @returns {QueryBuilder} - Instancia del QueryBuilder para encadenamiento
+   */
+  whereBetween(field, minValue, maxValue) {
+    const escapedField = this.escapeField(field);
+    
+    this.whereConditions.push({
+      field: escapedField,
+      operator: 'BETWEEN',
+      value: '? AND ?',
+      condition: 'AND'
+    });
+    
+    this.parameters.push(minValue, maxValue);
+    
+    return this;
+  }
+
+  /**
+   * Agrega una condición WHERE NOT BETWEEN
+   * @param {string} field - Campo
+   * @param {*} minValue - Valor mínimo
+   * @param {*} maxValue - Valor máximo
+   * @returns {QueryBuilder} - Instancia del QueryBuilder para encadenamiento
+   */
+  whereNotBetween(field, minValue, maxValue) {
+    const escapedField = this.escapeField(field);
+    
+    this.whereConditions.push({
+      field: escapedField,
+      operator: 'NOT BETWEEN',
+      value: '? AND ?',
+      condition: 'AND'
+    });
+    
+    this.parameters.push(minValue, maxValue);
+    
+    return this;
+  }
+
+  /**
+   * Agrega una condición WHERE LIKE
+   * @param {string} field - Campo
+   * @param {string} value - Valor para la comparación LIKE
+   * @returns {QueryBuilder} - Instancia del QueryBuilder para encadenamiento
+   */
+  whereLike(field, value) {
+    const escapedField = this.escapeField(field);
+    
+    this.whereConditions.push({
+      field: escapedField,
+      operator: 'LIKE',
+      value: '?',
+      condition: 'AND'
+    });
+    
+    this.parameters.push(value);
+    
+    return this;
+  }
+
+  /**
+   * Agrega una condición WHERE NOT LIKE
+   * @param {string} field - Campo
+   * @param {string} value - Valor para la comparación NOT LIKE
+   * @returns {QueryBuilder} - Instancia del QueryBuilder para encadenamiento
+   */
+  whereNotLike(field, value) {
+    const escapedField = this.escapeField(field);
+    
+    this.whereConditions.push({
+      field: escapedField,
+      operator: 'NOT LIKE',
+      value: '?',
+      condition: 'AND'
+    });
+    
+    this.parameters.push(value);
+    
+    return this;
+  }
+
+  /**
+   * Realiza un JOIN
+   * @param {string} table - Tabla a unir
+   * @param {string} first - Primer campo para la condición
+   * @param {string} operator - Operador de comparación
+   * @param {string} second - Segundo campo para la condición
+   * @param {string} type - Tipo de JOIN (INNER, LEFT, RIGHT, etc.)
+   * @returns {QueryBuilder} - Instancia del QueryBuilder para encadenamiento
+   */
+  join(table, first, operator, second, type = 'INNER') {
+    const escapedFirst = this.escapeField(first);
+    const escapedSecond = this.escapeField(second);
+    
+    this.joins.push({
+      type: type,
+      table: table,
+      condition: `${escapedFirst} ${operator} ${escapedSecond}`
+    });
+    
+    return this;
+  }
+
+  /**
+   * Realiza un LEFT JOIN
+   * @param {string} table - Tabla a unir
+   * @param {string} first - Primer campo para la condición
+   * @param {string} operator - Operador de comparación
+   * @param {string} second - Segundo campo para la condición
+   * @returns {QueryBuilder} - Instancia del QueryBuilder para encadenamiento
+   */
+  leftJoin(table, first, operator, second) {
+    return this.join(table, first, operator, second, 'LEFT');
+  }
+
+  /**
+   * Realiza un RIGHT JOIN
+   * @param {string} table - Tabla a unir
+   * @param {string} first - Primer campo para la condición
+   * @param {string} operator - Operador de comparación
+   * @param {string} second - Segundo campo para la condición
+   * @returns {QueryBuilder} - Instancia del QueryBuilder para encadenamiento
+   */
+  rightJoin(table, first, operator, second) {
+    return this.join(table, first, operator, second, 'RIGHT');
+  }
+
+  /**
+   * Realiza un INNER JOIN
+   * @param {string} table - Tabla a unir
+   * @param {string} first - Primer campo para la condición
+   * @param {string} operator - Operador de comparación
+   * @param {string} second - Segundo campo para la condición
+   * @returns {QueryBuilder} - Instancia del QueryBuilder para encadenamiento
+   */
+  innerJoin(table, first, operator, second) {
+    return this.join(table, first, operator, second, 'INNER');
+  }
+
+  /**
+   * Agrupa por campos
+   * @param {...string} fields - Campos para agrupar
+   * @returns {QueryBuilder} - Instancia del QueryBuilder para encadenamiento
+   */
+  groupBy(...fields) {
+    if (fields.length === 1 && Array.isArray(fields[0])) {
+      this.groupByFields = [...this.groupByFields, ...fields[0]];
+    } else {
+      this.groupByFields = [...this.groupByFields, ...fields];
+    }
+    return this;
+  }
+
+  /**
+   * Agrega una condición HAVING
+   * @param {string} field - Campo
+   * @param {string} operator - Operador
+   * @param {*} value - Valor
+   * @returns {QueryBuilder} - Instancia del QueryBuilder para encadenamiento
+   */
+  having(field, operator, value) {
+    const escapedField = this.escapeField(field);
+    
+    this.havingConditions.push({
+      field: escapedField,
+      operator: operator,
+      value: '?'
+    });
+    
+    this.parameters.push(value);
+    
+    return this;
+  }
+
+  /**
+   * Ordena los resultados
+   * @param {string} field - Campo para ordenar
+   * @param {string} direction - Dirección (ASC o DESC)
+   * @returns {QueryBuilder} - Instancia del QueryBuilder para encadenamiento
+   */
+  orderBy(field, direction = 'ASC') {
+    const escapedField = this.escapeField(field);
+    this.orderByFields.push(`${escapedField} ${direction.toUpperCase()}`);
+    return this;
+  }
+
+  /**
+   * Limita el número de resultados
+   * @param {number} limit - Límite
+   * @returns {QueryBuilder} - Instancia del QueryBuilder para encadenamiento
+   */
+  limit(limit) {
+    this.limitValue = parseInt(limit);
+    return this;
+  }
+
+  /**
+   * Establece el desplazamiento para la paginación
+   * @param {number} offset - Desplazamiento
+   * @returns {QueryBuilder} - Instancia del QueryBuilder para encadenamiento
+   */
+  offset(offset) {
+    this.offsetValue = parseInt(offset);
+    return this;
+  }
+
+  /**
+   * Agrega una unión UNION con otra consulta
+   * @param {QueryBuilder} query - Otra instancia de QueryBuilder
+   * @returns {QueryBuilder} - Instancia del QueryBuilder para encadenamiento
+   */
+  union(query) {
+    if (!(query instanceof QueryBuilder)) {
+      throw new Error('La unión debe ser con otra instancia de QueryBuilder');
+    }
+    
+    this.unionQueries.push(query);
+    return this;
+  }
+
+  /**
+   * Escapa un nombre de campo para prevenir inyección SQL
+   * @param {string|Function} field - Campo a escapar
+   * @returns {string} - Campo escapado
+   */
+  escapeField(field) {
+    // Si field es una función (caso especial para where(function(qb) {...})), no escapar
+    if (typeof field === 'function') {
+      return field;
+    }
+
+    // Si el campo es '*', no escapar (caso especial para SELECT *)
+    if (typeof field === 'string' && field === '*') {
+      return field;
+    }
+
+    // Verificar si el campo contiene una expresión o alias
+    if (typeof field === 'string' && (field.includes('(') || field.includes(' ') || field.includes('.'))) {
+      // Si es una expresión compleja o tiene alias, no escapar
+      return field;
+    }
+
+    // Si es un campo simple, escaparlo
+    return `\`${field}\``;
+  }
+
+  /**
+   * Genera la consulta SQL completa
+   * @returns {Object} - Objeto con la consulta SQL y los parámetros
+   */
+  toSQL() {
+    if (!this.tableName) {
+      throw new Error('Debe especificar una tabla usando el método table()');
+    }
+
+    let sql = 'SELECT ';
+
+    // Añadir campos SELECT
+    if (this.selectFields.length > 0) {
+      sql += this.selectFields.map(field => this.escapeField(field)).join(', ');
+    } else {
+      sql += '*';
+    }
+
+    // Añadir FROM
+    sql += ` FROM \`${this.tableName}\``;
+
+    // Añadir JOINs
+    for (const join of this.joins) {
+      sql += ` ${join.type} JOIN \`${join.table}\` ON ${join.condition}`;
+    }
+
+    // Añadir WHEREs
+    if (this.whereConditions.length > 0) {
+      sql += ' WHERE ';
+      
+      const conditions = this.whereConditions.map((condition, index) => {
+        const prefix = index === 0 ? '' : ` ${condition.condition} `;
+        return `${prefix}${condition.field} ${condition.operator} ${condition.value}`;
+      });
+      
+      sql += conditions.join('');
+    }
+
+    // Añadir GROUP BY
+    if (this.groupByFields.length > 0) {
+      sql += ' GROUP BY ' + this.groupByFields.map(field => this.escapeField(field)).join(', ');
+    }
+
+    // Añadir HAVING
+    if (this.havingConditions.length > 0) {
+      sql += ' HAVING ';
+      
+      const havings = this.havingConditions.map((condition, index) => {
+        const prefix = index === 0 ? '' : ' AND ';
+        return `${prefix}${condition.field} ${condition.operator} ${condition.value}`;
+      });
+      
+      sql += havings.join('');
+    }
+
+    // Añadir ORDER BY
+    if (this.orderByFields.length > 0) {
+      sql += ' ORDER BY ' + this.orderByFields.join(', ');
+    }
+
+    // Añadir LIMIT
+    if (this.limitValue !== null) {
+      sql += ` LIMIT ${this.limitValue}`;
+      
+      if (this.offsetValue !== null) {
+        sql += ` OFFSET ${this.offsetValue}`;
+      }
+    }
+
+    // Añadir UNIONs
+    for (const unionQuery of this.unionQueries) {
+      const unionSQL = unionQuery.toSQL();
+      sql += ` UNION (${unionSQL.sql})`;
+      this.parameters.push(...unionSQL.params);
+    }
+
+    return {
+      sql: sql,
+      params: [...this.parameters]
+    };
+  }
+
+  /**
+   * Ejecuta la consulta SELECT
+   * @returns {Promise<Array>} - Resultados de la consulta
+   */
+  async get() {
+    if (!this.adapter) {
+      throw new Error('No se ha configurado un adaptador para ejecutar la consulta. Use setAdapter() para configurar uno.');
+    }
+
+    const { sql, params } = this.toSQL();
+
+    // Disparar hook antes de ejecutar la consulta
+    const { hooks } = require('../index.js');
+    if (hooks) {
+      const hookResult = hooks.applyFilters('query_builder_before_execute', {
+        sql,
+        params,
+        queryBuilder: this
+      });
+
+      if (hookResult.cancelExecution) {
+        return hookResult.result || [];
+      }
+    }
+
+    try {
+      const results = await this.adapter.query(sql, params);
+
+      // Disparar hook después de ejecutar la consulta
+      if (hooks) {
+        hooks.doAction('query_builder_after_execute', {
+          sql,
+          params,
+          results,
+          queryBuilder: this
+        });
+      }
+
+      return results;
+    } catch (error) {
+      // Disparar hook en caso de error
+      if (hooks) {
+        hooks.doAction('query_builder_error', {
+          sql,
+          params,
+          error,
+          queryBuilder: this
+        });
+      }
+
+      throw error;
+    }
+  }
+
+  /**
+   * Ejecuta la consulta SELECT y obtiene el primer resultado
+   * @returns {Promise<Object|null>} - Primer resultado o null
+   */
+  async first() {
+    this.limit(1);
+    const results = await this.get();
+    return results.length > 0 ? results[0] : null;
+  }
+
+  /**
+   * Cuenta el número de registros
+   * @returns {Promise<number>} - Número de registros
+   */
+  async count() {
+    // Guardar los campos originales
+    const originalSelectFields = [...this.selectFields];
+    
+    // Establecer COUNT(*) como único campo
+    this.selectFields = ['COUNT(*) as count'];
+    
+    // Ejecutar la consulta
+    const results = await this.get();
+    
+    // Restaurar los campos originales
+    this.selectFields = originalSelectFields;
+    
+    return results.length > 0 ? parseInt(results[0].count) : 0;
+  }
+
+  /**
+   * Obtiene el valor máximo de un campo
+   * @param {string} field - Campo
+   * @returns {Promise<*>} - Valor máximo
+   */
+  async max(field) {
+    // Guardar los campos originales
+    const originalSelectFields = [...this.selectFields];
+    
+    // Establecer MAX(campo) como único campo
+    this.selectFields = [`MAX(${this.escapeField(field)}) as max_value`];
+    
+    // Ejecutar la consulta
+    const results = await this.get();
+    
+    // Restaurar los campos originales
+    this.selectFields = originalSelectFields;
+    
+    return results.length > 0 ? results[0].max_value : null;
+  }
+
+  /**
+   * Obtiene el valor mínimo de un campo
+   * @param {string} field - Campo
+   * @returns {Promise<*>} - Valor mínimo
+   */
+  async min(field) {
+    // Guardar los campos originales
+    const originalSelectFields = [...this.selectFields];
+    
+    // Establecer MIN(campo) como único campo
+    this.selectFields = [`MIN(${this.escapeField(field)}) as min_value`];
+    
+    // Ejecutar la consulta
+    const results = await this.get();
+    
+    // Restaurar los campos originales
+    this.selectFields = originalSelectFields;
+    
+    return results.length > 0 ? results[0].min_value : null;
+  }
+
+  /**
+   * Calcula la suma de un campo
+   * @param {string} field - Campo
+   * @returns {Promise<number>} - Suma
+   */
+  async sum(field) {
+    // Guardar los campos originales
+    const originalSelectFields = [...this.selectFields];
+    
+    // Establecer SUM(campo) como único campo
+    this.selectFields = [`SUM(${this.escapeField(field)}) as sum_value`];
+    
+    // Ejecutar la consulta
+    const results = await this.get();
+    
+    // Restaurar los campos originales
+    this.selectFields = originalSelectFields;
+    
+    return results.length > 0 ? parseFloat(results[0].sum_value) : 0;
+  }
+
+  /**
+   * Calcula el promedio de un campo
+   * @param {string} field - Campo
+   * @returns {Promise<number>} - Promedio
+   */
+  async avg(field) {
+    // Guardar los campos originales
+    const originalSelectFields = [...this.selectFields];
+    
+    // Establecer AVG(campo) como único campo
+    this.selectFields = [`AVG(${this.escapeField(field)}) as avg_value`];
+    
+    // Ejecutar la consulta
+    const results = await this.get();
+    
+    // Restaurar los campos originales
+    this.selectFields = originalSelectFields;
+    
+    return results.length > 0 ? parseFloat(results[0].avg_value) : 0;
+  }
+
+  /**
+   * Inserta un registro
+   * @param {Object} data - Datos a insertar
+   * @returns {Promise<Object>} - Resultado de la inserción
+   */
+  async insert(data) {
+    if (!this.adapter) {
+      throw new Error('No se ha configurado un adaptador para ejecutar la inserción. Use setAdapter() para configurar uno.');
+    }
+
+    if (!this.tableName) {
+      throw new Error('Debe especificar una tabla usando el método table()');
+    }
+
+    const columns = Object.keys(data);
+    const values = Object.values(data);
+    const placeholders = columns.map(() => '?').join(', ');
+
+    const sql = `INSERT INTO \`${this.tableName}\` (\`${columns.join('`, `')}\`) VALUES (${placeholders})`;
+
+    // Disparar hook antes de ejecutar la inserción
+    const { hooks } = require('../index.js');
+    if (hooks) {
+      const hookResult = hooks.applyFilters('query_builder_before_insert', {
+        sql,
+        data,
+        queryBuilder: this
+      });
+
+      if (hookResult.cancelExecution) {
+        return hookResult.result || {};
+      }
+    }
+
+    try {
+      const result = await this.adapter.query(sql, values);
+
+      // Disparar hook después de ejecutar la inserción
+      if (hooks) {
+        hooks.doAction('query_builder_after_insert', {
+          sql,
+          data,
+          result,
+          queryBuilder: this
+        });
+      }
+
+      return result;
+    } catch (error) {
+      // Disparar hook en caso de error
+      if (hooks) {
+        hooks.doAction('query_builder_insert_error', {
+          sql,
+          data,
+          error,
+          queryBuilder: this
+        });
+      }
+
+      throw error;
+    }
+  }
+
+  /**
+   * Actualiza registros
+   * @param {Object} data - Datos a actualizar
+   * @returns {Promise<number>} - Número de filas afectadas
+   */
+  async update(data) {
+    if (!this.adapter) {
+      throw new Error('No se ha configurado un adaptador para ejecutar la actualización. Use setAdapter() para configurar uno.');
+    }
+
+    if (!this.tableName) {
+      throw new Error('Debe especificar una tabla usando el método table()');
+    }
+
+    const updates = Object.keys(data).map(key => `\`${key}\` = ?`).join(', ');
+    const values = Object.values(data);
+
+    let sql = `UPDATE \`${this.tableName}\` SET ${updates}`;
+
+    // Añadir WHEREs
+    if (this.whereConditions.length > 0) {
+      sql += ' WHERE ';
+
+      const conditions = this.whereConditions.map((condition, index) => {
+        const prefix = index === 0 ? '' : ` ${condition.condition} `;
+        return `${prefix}${condition.field} ${condition.operator} ${condition.value}`;
+      });
+
+      sql += conditions.join('');
+    }
+
+    // Añadir ORDER BY
+    if (this.orderByFields.length > 0) {
+      sql += ' ORDER BY ' + this.orderByFields.join(', ');
+    }
+
+    // Añadir LIMIT
+    if (this.limitValue !== null) {
+      sql += ` LIMIT ${this.limitValue}`;
+    }
+
+    // Combinar los valores de actualización con los parámetros WHERE
+    const allParams = [...values, ...this.parameters];
+
+    // Disparar hook antes de ejecutar la actualización
+    const hooks = require('jerkjs').hooks;
+    if (hooks) {
+      const hookResult = hooks.applyFilters('query_builder_before_update', {
+        sql,
+        data,
+        queryBuilder: this
+      });
+
+      if (hookResult.cancelExecution) {
+        return hookResult.result || 0;
+      }
+    }
+
+    try {
+      const result = await this.adapter.query(sql, allParams);
+
+      // Disparar hook después de ejecutar la actualización
+      if (hooks) {
+        hooks.doAction('query_builder_after_update', {
+          sql,
+          data,
+          result,
+          queryBuilder: this
+        });
+      }
+
+      return result.affectedRows || 0;
+    } catch (error) {
+      // Disparar hook en caso de error
+      if (hooks) {
+        hooks.doAction('query_builder_update_error', {
+          sql,
+          data,
+          error,
+          queryBuilder: this
+        });
+      }
+
+      throw error;
+    }
+  }
+
+  /**
+   * Elimina registros
+   * @returns {Promise<number>} - Número de filas afectadas
+   */
+  async delete() {
+    if (!this.adapter) {
+      throw new Error('No se ha configurado un adaptador para ejecutar la eliminación. Use setAdapter() para configurar uno.');
+    }
+
+    if (!this.tableName) {
+      throw new Error('Debe especificar una tabla usando el método table()');
+    }
+
+    let sql = `DELETE FROM \`${this.tableName}\``;
+
+    // Añadir WHEREs
+    if (this.whereConditions.length > 0) {
+      sql += ' WHERE ';
+
+      const conditions = this.whereConditions.map((condition, index) => {
+        const prefix = index === 0 ? '' : ` ${condition.condition} `;
+        return `${prefix}${condition.field} ${condition.operator} ${condition.value}`;
+      });
+
+      sql += conditions.join('');
+    }
+
+    // Añadir ORDER BY
+    if (this.orderByFields.length > 0) {
+      sql += ' ORDER BY ' + this.orderByFields.join(', ');
+    }
+
+    // Añadir LIMIT
+    if (this.limitValue !== null) {
+      sql += ` LIMIT ${this.limitValue}`;
+    }
+
+    // Disparar hook antes de ejecutar la eliminación
+    const hooks = require('jerkjs').hooks;
+    if (hooks) {
+      const hookResult = hooks.applyFilters('query_builder_before_delete', {
+        sql,
+        queryBuilder: this
+      });
+
+      if (hookResult.cancelExecution) {
+        return hookResult.result || 0;
+      }
+    }
+
+    try {
+      const result = await this.adapter.query(sql, this.parameters);
+
+      // Disparar hook después de ejecutar la eliminación
+      if (hooks) {
+        hooks.doAction('query_builder_after_delete', {
+          sql,
+          result,
+          queryBuilder: this
+        });
+      }
+
+      return result.affectedRows || 0;
+    } catch (error) {
+      // Disparar hook en caso de error
+      if (hooks) {
+        hooks.doAction('query_builder_delete_error', {
+          sql,
+          error,
+          queryBuilder: this
+        });
+      }
+
+      throw error;
+    }
+  }
+
+  /**
+   * Reinicia todos los componentes de la consulta
+   * @returns {QueryBuilder} - Instancia del QueryBuilder para encadenamiento
+   */
+  reset() {
+    this.selectFields = [];
+    this.whereConditions = [];
+    this.joins = [];
+    this.groupByFields = [];
+    this.havingConditions = [];
+    this.orderByFields = [];
+    this.limitValue = null;
+    this.offsetValue = null;
+    this.unionQueries = [];
+    this.parameters = [];
+    
+    return this;
+  }
+}
+
+module.exports = QueryBuilder;