@areumtecnologia/mysql-db-handler 1.0.4 → 1.0.6

package/README.md

@@ -1,4 +1,4 @@
-# mysql-db-handler
+# @areumtecnologia/mysql-db-handler
 
 A powerful MySQL wrapper with connection pooling, singleton support, and advanced query handling for Node.js.
 
@@ -13,7 +13,7 @@ A powerful MySQL wrapper with connection pooling, singleton support, and advance
 ## Installation
 
 ```bash
-npm install mysql-db-handler
+npm install @areumtecnologia/mysql-db-handler
 ```
 
 ## Basic Usage
@@ -22,7 +22,7 @@ npm install mysql-db-handler
 You can create a new instance of the database class directly.
 
 ```javascript
-const { DataBase } = require('mysql-db-handler');
+const { DataBase } = require('@areumtecnologia/mysql-db-handler');
 
 const db = new DataBase({
     host: 'localhost',
@@ -50,16 +50,10 @@ try {
 The `DataBaseHandler` simplifies interactions with specific tables.
 
 ```javascript
-const { DataBaseHandler } = require('mysql-db-handler');
+const { DataBaseHandler } = require('@areumtecnologia/mysql-db-handler');
 
 // Initialize handler for 'customers' table
 const customers = new DataBaseHandler(db, 'customers');
-
-// Select all
-const allCustomers = await customers.select();
-
-// Select with conditions
-const activeCustomers = await customers.selectBy({ status: 1 });
 ```
 
 ---
@@ -202,20 +196,20 @@ See "Flexible Selection" above.
 #### `async selectBy(params)`
 Quickly select rows matching a specific object condition.
 *   **params**: Object. Key-value pairs for WHERE clause (e.g., `{ id: 5 }`).
-*   **Returns**: `Promise<Array>`.
+*   **Returns**: `Promise<Array>`. (contains rows array from query)
 
 #### `async insert(params)`
 Inserts a new row.
 *   **params**: Object. Key-value pairs representing column names and values.
-*   **Returns**: `Promise<OkPacket>` (contains insertId, affectedRows, etc).
+*   **Returns**: `Promise<OkPacket>` (contains insertId, or error).
 
 #### `async update(params, options)`
 See "Updating Records" above.
-*   **Returns**: `Promise<OkPacket>`.
+*   **Returns**: `Promise<OkPacket>`. (contains affectedRows or error).
 
 #### `async delete(conditions)`
 See "Deleting Records" above.
-*   **Returns**: `Promise<OkPacket>`.
+*   **Returns**: `Promise<OkPacket>`. (contains affectedRows or error)
 
 #### `async selectToDatatable(rawDtQuery, strictCondition)`
 Helper for server-side Datatables.net processing.

package/lib/databaseHandler.js

@@ -169,7 +169,7 @@ class DatabaseHandler {
         }
     }
 
-    async select(params, clauses = {}) {
+    async selectOld(params, clauses = {}) {
         if (params != null && !Array.isArray(params)) {
             return new Error('O parâmetro "params" deve ser um array');
         }
@@ -209,6 +209,81 @@ class DatabaseHandler {
         return rows;
     }
 
+    async select(params, clauses = {}) {
+        if (params != null && !Array.isArray(params)) {
+            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(' ')}` : '';
+
+        // Cláusulas adicionais
+        const groupByClause = clauses['GROUPBY'] ? ` GROUP BY ${clauses['GROUPBY']}` : '';
+        const havingClause = clauses['HAVING'] ? ` HAVING ${clauses['HAVING']}` : '';
+        const orderClause = clauses['ORDERBY'] ? ` ORDER BY ${clauses['ORDERBY']}` : '';
+        const descClause = clauses['DESC'] ? ` DESC ` : '';
+        const limitClause = clauses['LIMIT'] ? ` LIMIT ${clauses['LIMIT']}` : '';
+        const offsetClause = clauses['OFFSET'] ? ` OFFSET ${clauses['OFFSET']}` : '';
+
+        const sql = `SELECT *${this.expression ?? ''} FROM ${this.table}${whereClause}${groupByClause}${havingClause}${orderClause}${descClause}${limitClause}${offsetClause}`;
+
+        const rows = await this.executeQuery(sql, values);
+        return rows;
+    }
+
     async insert(params) {
         const sql = `INSERT INTO ${this.table} SET ?`;
         const result = await this.executeQuery(sql, params);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@areumtecnologia/mysql-db-handler",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "description": "A powerful MySQL wrapper with connection pooling, singleton support, and advanced query handling for Node.js.",
   "main": "index.js",
   "scripts": {
@@ -9,6 +9,6 @@
   "author": "Renan Moreira / Áreum Tecnologia",
   "license": "MIT",
   "dependencies": {
-    "mysql2": "^3.0.0"
+    "mysql2": "^3.22.5"
   }
 }