@areumtecnologia/mysql-db-handler 1.0.3 → 1.0.5

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,22 +50,37 @@ 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 });
 ```
 
 ---
 
 ## Advanced Usage & Examples
 
+### Inserting Records (`insert`)
+
+The `insert` method adds a new row to the table.
+
+**Parameters:**
+*   `params` (Object): An object where keys match the column names and values are the data to insert.
+
+**Example:**
+
+```javascript
+const logs = new DataBaseHandler(db, 'app_logs');
+
+const result = await logs.insert({
+    level: 'info',
+    message: 'User logged in',
+    timestamp: new Date()
+});
+// Executes: INSERT INTO app_logs SET `level` = ?, `message` = ?, `timestamp` = ?
+console.log(`Inserted Row ID: ${result.insertId}`);
+```
+
 ### Flexible Selection (`select`)
 
 The `select` method allows you to build complex queries using an array of parameters and a clauses object.

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.3",
+  "version": "1.0.5",
   "description": "A powerful MySQL wrapper with connection pooling, singleton support, and advanced query handling for Node.js.",
   "main": "index.js",
   "scripts": {