@areumtecnologia/mysql-db-handler 1.0.8 → 1.0.9

package/README.md

@@ -224,7 +224,9 @@ console.log('Inserted ID:', result.insertId);
 
 ### Updating Records (`update`)
 
-Performs selective updates by specifying both a `set` payload and a `where` filter.
+Performs selective updates by specifying both a `set` payload and a `where` filter. The `where` filter supports both standard flat objects (where conditions are implicitly joined by `AND` using `=` or `REGEXP`) and complex array configurations (with operators, `AND`, and `OR`), sharing the same advanced querying capabilities as the `select` method.
+
+#### 1. Simple Object Syntax (Implicit AND, = operator)
 
 ```javascript
 const result = await usersHandler.update({
@@ -239,6 +241,52 @@ const result = await usersHandler.update({
 });
 
 console.log('Affected rows:', result.affectedRows);
+// Executes: UPDATE users SET `status` = ?, `notes` = ? WHERE `id` = ? AND `status` = ?
+```
+
+#### 2. Advanced Array Syntax (with operators, AND/OR, and IN)
+
+You can pass an array of condition objects interleaved with `AND` or `OR` string elements to construct complex queries:
+
+```javascript
+// Example updating records based on numeric thresholds and logical operators
+const result = await usersHandler.update({
+    set: {
+        status: 'inactive'
+    },
+    where: [
+        { age: 18, operator: '<' },
+        'AND',
+        { status: 'active' }
+    ]
+});
+// Executes: UPDATE users SET `status` = ? WHERE `age` < ? AND `status` = ?
+
+// Example updating records using automatic IN operator detection
+const result = await usersHandler.update({
+    set: {
+        role: 'archived'
+    },
+    where: [
+        { id: [10, 20, 30] } // Automatically builds: WHERE `id` IN (?, ?, ?)
+    ]
+});
+// Executes: UPDATE users SET `role` = ? WHERE `id` IN (?, ?, ?)
+
+// Example combining complex logic (AND/OR)
+const result = await usersHandler.update({
+    set: {
+        category: 'Premium'
+    },
+    where: [
+        { total_purchases: 1000, operator: '>' },
+        'AND',
+        { status: 'active' },
+        'OR',
+        { is_vip: 1 }
+    ]
+});
+// Executes: UPDATE users SET `category` = ? WHERE `total_purchases` > ? AND `status` = ? OR `is_vip` = ?
 ```
 
 ### Deleting Records (`delete`)

package/lib/databaseHandler.js

@@ -62,6 +62,67 @@ class DatabaseHandler {
         return { sql: `(${clauses.join(' ')})`, bindings };
     }
 
+    /**
+     * @private
+     * Constrói a cláusula WHERE (sem a palavra-chave WHERE) e seus bindings associados.
+     * @param {Object|Array} where - Condições do where.
+     * @param {boolean} useRegex - Se deve usar REGEXP por padrão (para compatibilidade com update).
+     * @returns {{ sql: string, bindings: Array }}
+     */
+    _buildWhereClause(where, useRegex = false) {
+        if (!where) {
+            return { sql: '', bindings: [] };
+        }
+
+        const conditions = [];
+        const bindings = [];
+
+        if (Array.isArray(where)) {
+            where.forEach((param) => {
+                if (typeof param === 'object' && param !== null && !Array.isArray(param)) {
+                    const entries = Object.entries(param);
+                    if (entries.length === 0) return;
+
+                    const [key, value] = entries[0];
+                    const [operatorKey, operatorValue] = entries[1] || [];
+
+                    let op = operatorValue ?? (useRegex ? 'REGEXP' : '=');
+                    let upperOp = String(op).toUpperCase();
+
+                    if (Array.isArray(value) && upperOp === '=') {
+                        op = 'IN';
+                        upperOp = 'IN';
+                    }
+
+                    if (Array.isArray(value) && (upperOp === 'IN' || upperOp === 'NOT IN')) {
+                        if (value.length === 0) {
+                            conditions.push(upperOp === 'IN' ? '1 = 0' : '1 = 1');
+                        } else {
+                            const placeholders = value.map(() => '?').join(', ');
+                            conditions.push(`\`${key}\` ${op} (${placeholders})`);
+                            bindings.push(...value); 
+                        }
+                    } else {
+                        const condition = `\`${key}\` ${op} ?`;
+                        conditions.push(condition);
+                        bindings.push(value);
+                    }
+                } else if (typeof param === 'string') {
+                    conditions.push(param.toUpperCase());
+                }
+            });
+            return { sql: conditions.join(' '), bindings };
+        } else if (typeof where === 'object' && where !== null) {
+            const operator = useRegex ? 'REGEXP' : '=';
+            const keys = Object.keys(where);
+            const sql = keys.map(key => `\`${key}\` ${operator} ?`).join(' AND ');
+            const bindings = Object.values(where);
+            return { sql, bindings };
+        }
+
+        return { sql: '', bindings: [] };
+    }
+
     async selectToDatatable(rawDtQuery, strictCondition = []) {
         // NOVO: Hidrata o objeto da requisição para o formato aninhado correto.
         const dtQuery = this._hydrateObject(rawDtQuery);
@@ -214,61 +275,8 @@ class DatabaseHandler {
             return new Error('O parâmetro "params" deve ser um array');
         }
 
-        const conditions = [];
-        const values = [];
-
-        if (params && params.length) {
-            // Dica: Troquei map por forEach. O map é para transformar arrays, 
-            // como você só está preenchendo variáveis externas, forEach é semanticamente correto.
-            params.forEach((param) => {
-                if (typeof param === 'object' && !Array.isArray(param)) {
-                    const entries = Object.entries(param);
-                    const [key, value] = entries[0];
-                    const [operatorKey, operatorValue] = entries[1] || [];
-
-                    // --- INÍCIO DAS MODIFICAÇÕES PARA SUPORTE AO IN ---
-
-                    // 1. Define o operador (padrão é '=')
-                    let op = operatorValue ?? '=';
-                    const upperOp = op.toUpperCase();
-
-                    // 2. "Magia": Se o valor for um array e não tiver operador (ou for '='), 
-                    // converte automaticamente para 'IN' para facilitar sua vida.
-                    if (Array.isArray(value) && upperOp === '=') {
-                        op = 'IN';
-                    }
-
-                    // 3. Lógica específica para IN e NOT IN
-                    if (Array.isArray(value) && (upperOp === 'IN' || upperOp === 'NOT IN')) {
-                        if (value.length === 0) {
-                            // O SQL não permite "IN ()". 
-                            // Um IN vazio nunca encontra nada (falso), um NOT IN vazio encontra tudo (verdadeiro).
-                            conditions.push(upperOp === 'IN' ? '1 = 0' : '1 = 1');
-                        } else {
-                            // Cria a string de placeholders: "?, ?, ?" baseada no tamanho do array
-                            const placeholders = value.map(() => '?').join(', ');
-                            conditions.push(`\`${key}\` ${op} (${placeholders})`);
-                            
-                            // Espalha os valores do array individualmente no array de values
-                            values.push(...value); 
-                        }
-                    } else {
-                        // 4. Lógica original para valores únicos (string, number, boolean, etc)
-                        // ou outros operadores (LIKE, REGEXP, >, <, etc)
-                        const condition = `\`${key}\` ${op} ?`;
-                        conditions.push(condition);
-                        values.push(value);
-                    }
-
-                    // --- FIM DAS MODIFICAÇÕES ---
-
-                } else if (typeof param === 'string') {
-                    conditions.push(param.toUpperCase());
-                }
-            });
-        }
-
-        const whereClause = conditions.length > 0 ? ` WHERE ${conditions.join(' ')}` : '';
+        const { sql: whereSql, bindings: values } = this._buildWhereClause(params);
+        const whereClause = whereSql ? ` WHERE ${whereSql}` : '';
 
         // Cláusulas adicionais
         const groupByClause = clauses['GROUPBY'] ? ` GROUP BY ${clauses['GROUPBY']}` : '';
@@ -292,14 +300,16 @@ class DatabaseHandler {
 
     async update(params, options = {}) {
         // Inicializa a string SQL para a cláusula SET
-        const operator = options.useRegex ? 'REGEXP' : '=';
         let setClause = Object.keys(params.set).map(key => `\`${key}\` = ?`).join(', ');
+        let setValues = Object.values(params.set);
+
         // Inicializa a string SQL para a cláusula WHERE
-        let whereClause = Object.keys(params.where).map(key => `\`${key}\` ${operator} ?`).join(' AND ');
+        const { sql: whereClause, bindings: whereValues } = this._buildWhereClause(params.where, !!options.useRegex);
+
         // Constrói a consulta SQL completa
         const sql = `UPDATE ${this.table} SET ${setClause} WHERE ${whereClause}`;
         // Combina os valores SET e WHERE em um único array
-        const values = [...Object.values(params.set), ...Object.values(params.where)];
+        const values = [...setValues, ...whereValues];
         // Executa a consulta
         const result = await this.executeQuery(sql, values);
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@areumtecnologia/mysql-db-handler",
-  "version": "1.0.8",
+  "version": "1.0.9",
   "description": "A powerful MySQL wrapper with connection pooling, singleton support, and advanced query handling for Node.js.",
   "main": "index.js",
   "scripts": {