@areumtecnologia/mysql-db-handler 1.0.8 → 1.0.10

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/index.js

@@ -1,4 +1,5 @@
 // Áreum Tecnologia - Renan Moreira - renan.moreira@areum.com.br
+const DataBaseCache = require('./lib/database-cache');
 const DataBase = require('./lib/database');
 const DataBaseHandler = require('./lib/databaseHandler');
 // We do not export the singleton by default in a library usually, 
@@ -6,5 +7,6 @@ const DataBaseHandler = require('./lib/databaseHandler');
 
 module.exports = {
     DataBase,
-    DataBaseHandler
+    DataBaseHandler,
+    DataBaseCache
 };

package/lib/database-cache.js

@@ -2,7 +2,7 @@
 const mysql = require('mysql2/promise');
 const NodeCache = require('node-cache');
 
-class DataBase {
+class DataBaseCache {
     constructor(config = {}) {
         this.config = config;
         this.pool = mysql.createPool(this.config); // The pool is created once when the instance is created.
@@ -74,4 +74,4 @@ class DataBase {
     }
 }
 
-module.exports = DataBase;
+module.exports = DataBaseCache;

package/lib/database.js

@@ -31,8 +31,9 @@ class DataBase {
      * Executes a SQL query using a pooled connection.
      * @param {string} sql - The SQL query to execute.
      * @param {Array} [params] - The parameters for the SQL query.
-     * @returns {Promise<Array>} The result set from the query.
-     * @throws {Error} Throws an error if the query fails.
+     * @returns {Promise<Array|{error: Error}>} The result set from the query,
+     *         or an object with an `error` property if the query fails.
+     *         This prevents unhandled exceptions from crashing the application.
      */
     async query(sql, params) {
         let connection; // Mova a declaração da conexão para fora do bloco try
@@ -44,9 +45,12 @@ class DataBase {
             const [rows] = await connection.query(sql, params);
             return rows;
         } catch (error) {
-            // Passo 3: Se a query falhar, logar e retornar o erro no formato desejado
+            // Passo 3: Logar o erro para diagnóstico
             console.error('Erro na execução da query:', error);
-            return { error }; // Mantém o retorno do erro como um objeto
+
+            // Retorna o erro encapsulado em { error } para evitar crashes não tratados,
+            // mantendo o contrato documentado no README.
+            return { error };
         } finally {
             // Passo 4: Este bloco SEMPRE será executado, independentemente de sucesso ou falha no 'try'
             if (connection) {

package/lib/databaseHandler.js

@@ -49,19 +49,101 @@ class DatabaseHandler {
         const bindings = [];
         for (const item of strictCondition) {
             if (typeof item === 'string') {
+                // Operadores lógicos (AND / OR) são inseridos como-is, sem parênteses.
                 clauses.push(item.toUpperCase());
             } else if (typeof item === 'object' && item !== null) {
                 const key = Object.keys(item).find(k => k !== 'operator');
                 if (!key) continue;
                 const value = item[key];
-                const operator = item.operator || '=';
-                clauses.push(`\`${key}\` ${operator} ?`);
-                bindings.push(value);
+                let operator = item.operator || '=';
+                let upperOp = String(operator).toUpperCase();
+
+                // Suporte a arrays => IN / NOT IN (consistente com _buildWhereClause)
+                if (Array.isArray(value) && upperOp === '=') {
+                    operator = 'IN';
+                    upperOp = 'IN';
+                }
+
+                if (Array.isArray(value) && (upperOp === 'IN' || upperOp === 'NOT IN')) {
+                    if (value.length === 0) {
+                        clauses.push(upperOp === 'IN' ? '1 = 0' : '1 = 1');
+                    } else {
+                        const placeholders = value.map(() => '?').join(', ');
+                        clauses.push(`\`${key}\` ${operator} (${placeholders})`);
+                        bindings.push(...value);
+                    }
+                } else {
+                    clauses.push(`\`${key}\` ${operator} ?`);
+                    bindings.push(value);
+                }
             }
         }
+        // Junta com espaço para preservar operadores AND/OR intercalados.
+        // Ex: "(a = ? AND b = ?)" em vez de "(a = ? b = ?)" que era inválido.
         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);
@@ -121,12 +203,31 @@ class DatabaseHandler {
             // --- Queries ---
             const baseWhereSql = baseWhere.sql ? `WHERE ${baseWhere.sql}` : '';
             const totalCountSql = `SELECT COUNT(*) as total FROM ${this.table} ${baseWhereSql}`;
-            const [totalResult] = await this.executeQuery(totalCountSql, baseWhere.bindings);
-            const recordsTotal = totalResult.total;
+            const totalResult = await this.executeQuery(totalCountSql, baseWhere.bindings);
+            // Contrato: executeQuery propaga { error } em caso de falha (não lança).
+            if (totalResult && totalResult.error) {
+                return {
+                    draw: parseInt(draw || 0),
+                    recordsTotal: 0,
+                    recordsFiltered: 0,
+                    data: [],
+                    error: totalResult.error.message
+                };
+            }
+            const recordsTotal = (totalResult && totalResult[0] && totalResult[0].total) || 0;
 
             const filteredCountSql = `SELECT COUNT(*) as total FROM ${this.table} ${whereSql}`;
-            const [filteredResult] = await this.executeQuery(filteredCountSql, finalBindings);
-            const recordsFiltered = filteredResult.total;
+            const filteredResult = await this.executeQuery(filteredCountSql, finalBindings);
+            if (filteredResult && filteredResult.error) {
+                return {
+                    draw: parseInt(draw || 0),
+                    recordsTotal: parseInt(recordsTotal),
+                    recordsFiltered: 0,
+                    data: [],
+                    error: filteredResult.error.message
+                };
+            }
+            const recordsFiltered = (filteredResult && filteredResult[0] && filteredResult[0].total) || 0;
 
             // CORREÇÃO: Construção segura da cláusula SELECT para evitar vírgulas duplas.
             const selectFields = ['*'];
@@ -136,6 +237,15 @@ class DatabaseHandler {
             }
             const dataSql = `SELECT ${selectFields.join(', ')} FROM ${this.table} ${whereSql} ${orderSql} ${limitSql}`;
             const data = await this.executeQuery(dataSql, finalBindings);
+            if (data && data.error) {
+                return {
+                    draw: parseInt(draw || 0),
+                    recordsTotal: parseInt(recordsTotal),
+                    recordsFiltered: parseInt(recordsFiltered),
+                    data: [],
+                    error: data.error.message
+                };
+            }
 
             return {
                 draw: parseInt(draw || 0),
@@ -214,61 +324,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 +349,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,14 +1,14 @@
 {
   "name": "@areumtecnologia/mysql-db-handler",
-  "version": "1.0.8",
+  "version": "1.0.10",
   "description": "A powerful MySQL wrapper with connection pooling, singleton support, and advanced query handling for Node.js.",
   "main": "index.js",
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "node tests/update_operators.test.js && node tests/selectToDatatable.test.js"
   },
   "author": "Renan Moreira / Áreum Tecnologia",
   "license": "MIT",
   "dependencies": {
-    "mysql2": "^3.22.5"
+    "mysql2": "^3.23.1"
   }
 }

package/lib/database-singleton.js

@@ -1,19 +0,0 @@
-// Áreum Tecnologia - Renan Moreira - renan.moreira@areum.com.br
-// src/database/database-singleton.js
-// Exemplo Singleton para a conexão com o banco de dados
-const { DB_HOST, DB_USER, DB_PASS } = require('../constants');
-const DataBase = require("./database");
-
-const dbi = new DataBase({
-    host: DB_HOST,
-    user: DB_USER,
-    password: DB_PASS,
-    database: '',
-    charset: "utf8mb4",
-    timezone: "-03:00",
-    connectionLimit: 1, // Ajustado para um limite de conexão mais comum
-    waitForConnections: true,
-    queueLimit: 0
-});
-// console.log("DATABASE SINGLETON CREATED", dbi.id);
-module.exports = dbi;