andres-db 2.2.0

package/README.md

@@ -0,0 +1,202 @@
+
+# 🗄️ EasyDB
+
+![License](https://img.shields.io/badge/license-MIT-green.svg)
+![Node](https://img.shields.io/badge/node-%3E%3D16-brightgreen)
+![SQLite](https://img.shields.io/badge/database-SQLite-blue)
+![npm](https://img.shields.io/badge/npm-ready-red)
+
+**EasyDB** es una interfaz **simple, moderna y poderosa** para trabajar con **SQLite** en Node.js usando `better-sqlite3`.
+
+Diseñada para ofrecer **respuestas JSON limpias**, **creación automática de tablas**, **operaciones CRUD intuitivas** y utilidades avanzadas sin escribir SQL complejo.
+
+---
+
+## ✨ Características
+
+- 📦 SQLite rápido con `better-sqlite3`
+- ⚡ CRUD completo
+- 🧠 Creación automática de tablas
+- 🧩 Columnas dinámicas
+- 🔎 Búsquedas avanzadas
+- 🔁 Transacciones seguras
+- 📤 Exportar / importar JSON
+- 💾 Backups automáticos
+- 📊 Estadísticas del sistema
+- 🧾 Respuestas JSON estándar
+- 🛠️ Consultas SQL personalizadas
+
+---
+
+## 📦 Instalación
+
+```bash
+npm install andres-db
+```
+
+Requiere **Node.js v16+**
+
+---
+
+## 🚀 Uso rápido
+
+```js
+const db = require('andres-db');
+
+db.create('users', {
+  name: 'Juan',
+  email: 'juan@email.com',
+  age: 25
+});
+
+const users = db.read('users');
+console.log(users.data);
+```
+
+---
+
+## ⚙️ Configuración
+
+```js
+const db = require('andres-db').createInstance({
+  filename: './db/app.db',
+  verbose: true,
+  jsonResponse: true
+});
+```
+
+---
+
+## 🧱 Crear registros
+
+```js
+db.create('products', {
+  name: 'Laptop',
+  price: 1200,
+  stock: 10
+});
+```
+
+### Múltiples registros
+
+```js
+db.create('users', [
+  { name: 'Ana', age: 22 },
+  { name: 'Luis', age: 30 }
+]);
+```
+
+---
+
+## 📖 Leer datos
+
+```js
+db.read('users', { age: { $gte: 18 } });
+```
+
+```js
+db.readOne('users', { id: 1 });
+```
+
+---
+
+## ✏️ Actualizar
+
+```js
+db.update('users', { id: 1 }, { age: 26 });
+```
+
+---
+
+## ❌ Eliminar
+
+```js
+db.delete('users', { id: 1 });
+```
+
+---
+
+## 🔎 Buscar texto
+
+```js
+db.search('users', ['name', 'email'], 'juan');
+```
+
+---
+
+## 🧩 Agregar columnas
+
+```js
+db.addColumn('users', 'phone', 'TEXT');
+```
+
+```js
+db.addColumns('users', [
+  { name: 'city', type: 'TEXT' },
+  { name: 'active', type: 'INTEGER', defaultValue: 1 }
+]);
+```
+
+---
+
+## 🔁 Transacciones
+
+```js
+db.transaction((db) => {
+  db.create('accounts', { name: 'Cuenta A' });
+  db.create('accounts', { name: 'Cuenta B' });
+});
+```
+
+---
+
+## 🧪 SQL personalizado
+
+```js
+db.query('SELECT * FROM users WHERE age > ?', [20]);
+```
+
+---
+
+## 📤 Exportar / 📥 Importar
+
+```js
+db.exportToJSON();
+```
+
+```js
+db.importFromJSON({ users: [{ name: 'Carlos', age: 28 }] });
+```
+
+---
+
+## 💾 Backup
+
+```js
+db.backup('./backup/db_backup.db');
+```
+
+---
+
+## 📊 Estadísticas
+
+```js
+db.getStats();
+```
+
+---
+
+## 🧑‍💻 Autor
+
+**ANDRES CARVAJAL**
+
+🌐 https://andres-carvajal.vercel.app  
+📸 Instagram: [@05_carvajal](https://instagram.com/05_carvajal)
+
+---
+
+## 📄 Licencia
+
+![MIT](https://img.shields.io/badge/License-MIT-yellow.svg)
+
+Este proyecto está bajo la licencia **MIT**.

package/index.js

@@ -0,0 +1,1151 @@
+/**
+ * db.js - Base de Datos SQL Simplificada
+ * @version 2.2.0
+ * @license MIT
+ * @description Interfaz JavaScript simple para bases de datos SQLite con respuestas JSON
+ */
+
+const Database = require('better-sqlite3');
+const fs = require('fs');
+const path = require('path');
+
+// ===========================================
+// VARIABLE GLOBAL PARA RUTA DE LA BASE DE DATOS
+// ===========================================
+const DEFAULT_DB_PATH = './db/database.db'; // <-- VARIABLE GLOBAL
+
+// Función para asegurar que el directorio existe
+function ensureDirectoryExists(filePath) {
+    const dir = path.dirname(filePath);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+        console.log(`Directorio creado: ${path.resolve(dir)}`);
+    }
+    return dir;
+}
+
+class EasyDB {
+    /**
+     * Crea una nueva instancia de EasyDB
+     * @param {string|Object} config - Configuración de la base de datos
+     * @param {string} [config.filename=DEFAULT_DB_PATH] - Nombre del archivo
+     * @param {boolean} [config.memory=false] - Usar base de datos en memoria
+     * @param {boolean} [config.readonly=false] - Modo solo lectura
+     * @param {boolean} [config.verbose=false] - Mostrar logs SQL
+     * @param {boolean} [config.jsonResponse=true] - Formatear respuestas como JSON limpio
+     * @param {boolean} [config.autoCreateDir=true] - Crear directorio automáticamente si no existe
+     */
+    constructor(config = DEFAULT_DB_PATH) {
+        this.config = {
+            filename: DEFAULT_DB_PATH,
+            memory: false,
+            readonly: false,
+            verbose: false,
+            jsonResponse: true,
+            autoCreateDir: true,
+            ...(typeof config === 'string' ? { filename: config } : config)
+        };
+
+        // Crear directorio automáticamente si es necesario
+        if (!this.config.memory && this.config.autoCreateDir) {
+            ensureDirectoryExists(this.config.filename);
+        }
+
+        // Opciones de conexión
+        const dbOptions = {
+            verbose: this.config.verbose ? console.log : null,
+            readonly: this.config.readonly
+        };
+
+        // Establecer conexión
+        if (this.config.memory) {
+            this.db = new Database(':memory:', dbOptions);
+            if (this.config.verbose) console.log('EasyDB: Conectado a base de datos en memoria');
+        } else {
+            try {
+                this.db = new Database(this.config.filename, dbOptions);
+                if (this.config.verbose) {
+                    console.log(`EasyDB: Conectado a ${this.config.filename}`);
+                    console.log(`Ruta completa: ${path.resolve(this.config.filename)}`);
+                }
+            } catch (error) {
+                console.error(`Error conectando a ${this.config.filename}:`, error.message);
+                throw error;
+            }
+        }
+
+        // Optimizaciones
+        this.db.pragma('foreign_keys = ON');
+        this.db.pragma('journal_mode = WAL');
+        this.db.pragma('synchronous = NORMAL');
+        
+        // Inicializar sistema de metadatos
+        this._initMetadata();
+    }
+
+    /**
+     * Inicializa la tabla de metadatos
+     * @private
+     */
+    _initMetadata() {
+        const sql = `
+            CREATE TABLE IF NOT EXISTS _easydb_meta (
+                key TEXT PRIMARY KEY,
+                value TEXT,
+                updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+            )
+        `;
+        this.db.exec(sql);
+        this._setMeta('version', '2.2.0');
+        this._setMeta('created_at', new Date().toISOString());
+        this._setMeta('db_path', this.config.filename);
+    }
+
+    /**
+     * Establece un metadato
+     * @private
+     */
+    _setMeta(key, value) {
+        const sql = `INSERT OR REPLACE INTO _easydb_meta (key, value) VALUES (?, ?)`;
+        this.db.prepare(sql).run(key, value);
+    }
+
+    /**
+     * Obtiene un metadato
+     * @private
+     */
+    _getMeta(key) {
+        const sql = 'SELECT value FROM _easydb_meta WHERE key = ?';
+        const result = this.db.prepare(sql).get(key);
+        return result ? result.value : null;
+    }
+
+    /**
+     * Verifica si una tabla existe
+     * @param {string} tableName - Nombre de la tabla
+     * @returns {boolean}
+     */
+    tableExists(tableName) {
+        const sql = `SELECT name FROM sqlite_master WHERE type='table' AND name = ?`;
+        return !!this.db.prepare(sql).get(tableName);
+    }
+
+    /**
+     * Crea una tabla automáticamente basada en datos de muestra
+     * @private
+     */
+    _autoCreateTable(tableName, sampleData) {
+        const columns = ['id INTEGER PRIMARY KEY AUTOINCREMENT'];
+        
+        // Mapear tipos JavaScript a tipos SQL
+        for (const [key, value] of Object.entries(sampleData)) {
+            let columnType = 'TEXT';
+            
+            if (value === null || value === undefined) {
+                columnType = 'TEXT';
+            } else if (typeof value === 'number') {
+                columnType = Number.isInteger(value) ? 'INTEGER' : 'REAL';
+            } else if (typeof value === 'boolean') {
+                columnType = 'INTEGER';
+            } else if (value instanceof Date) {
+                columnType = 'TEXT';
+            } else if (typeof value === 'object') {
+                columnType = 'TEXT'; // JSON
+            }
+            
+            columns.push(`${key} ${columnType}`);
+        }
+        
+        columns.push('created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP');
+        columns.push('updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP');
+        
+        // Crear tabla
+        const sql = `CREATE TABLE ${tableName} (${columns.join(', ')})`;
+        this.db.exec(sql);
+        
+        // Crear trigger para updated_at
+        const triggerSql = `
+            CREATE TRIGGER IF NOT EXISTS ${tableName}_updated
+            AFTER UPDATE ON ${tableName}
+            BEGIN
+                UPDATE ${tableName} 
+                SET updated_at = CURRENT_TIMESTAMP 
+                WHERE id = NEW.id;
+            END
+        `;
+        this.db.exec(triggerSql);
+        
+        if (this.config.verbose) {
+            console.log(`EasyDB: Tabla '${tableName}' creada automáticamente`);
+        }
+    }
+
+    /**
+     * Agrega una nueva columna a una tabla existente
+     * @param {string} tableName - Nombre de la tabla
+     * @param {string} columnName - Nombre de la nueva columna
+     * @param {string} columnType - Tipo de dato (INTEGER, TEXT, REAL, BLOB, etc.)
+     * @param {*} [defaultValue] - Valor por defecto (opcional)
+     * @returns {Object} - Respuesta JSON con resultado de la operación
+     */
+    addColumn(tableName, columnName, columnType, defaultValue = null) {
+        try {
+            if (!this.tableExists(tableName)) {
+                throw new Error(`La tabla '${tableName}' no existe`);
+            }
+            
+            // Verificar si la columna ya existe
+            const tableInfo = this.tableInfo(tableName);
+            if (tableInfo.success) {
+                const columnExists = tableInfo.columns.some(col => col.name === columnName);
+                if (columnExists) {
+                    throw new Error(`La columna '${columnName}' ya existe en la tabla '${tableName}'`);
+                }
+            }
+            
+            // Construir la sentencia ALTER TABLE
+            let sql = `ALTER TABLE ${tableName} ADD COLUMN ${columnName} ${columnType}`;
+            
+            if (defaultValue !== null) {
+                const defaultValueStr = typeof defaultValue === 'string' 
+                    ? `'${defaultValue.replace(/'/g, "''")}'` 
+                    : defaultValue;
+                sql += ` DEFAULT ${defaultValueStr}`;
+            }
+            
+            if (this.config.verbose) console.log(`SQL: ${sql}`);
+            
+            this.db.exec(sql);
+            
+            return {
+                success: true,
+                operation: 'addColumn',
+                table: tableName,
+                column: columnName,
+                type: columnType,
+                defaultValue: defaultValue,
+                message: `Columna '${columnName}' agregada exitosamente a la tabla '${tableName}'`,
+                timestamp: new Date().toISOString()
+            };
+            
+        } catch (error) {
+            return {
+                success: false,
+                operation: 'addColumn',
+                error: error.message,
+                timestamp: new Date().toISOString()
+            };
+        }
+    }
+
+    /**
+     * Agrega múltiples columnas a una tabla existente
+     * @param {string} tableName - Nombre de la tabla
+     * @param {Array} columns - Array de objetos {name, type, defaultValue}
+     * @returns {Object} - Respuesta JSON con resultado de la operación
+     */
+    addColumns(tableName, columns) {
+        try {
+            const results = [];
+            
+            for (const column of columns) {
+                const result = this.addColumn(
+                    tableName, 
+                    column.name, 
+                    column.type, 
+                    column.defaultValue
+                );
+                results.push(result);
+            }
+            
+            const successful = results.filter(r => r.success).length;
+            
+            return {
+                success: successful === columns.length,
+                operation: 'addColumns',
+                table: tableName,
+                results: results,
+                added: successful,
+                failed: columns.length - successful,
+                message: `Agregadas ${successful} de ${columns.length} columnas a la tabla '${tableName}'`,
+                timestamp: new Date().toISOString()
+            };
+            
+        } catch (error) {
+            return {
+                success: false,
+                operation: 'addColumns',
+                error: error.message,
+                timestamp: new Date().toISOString()
+            };
+        }
+    }
+
+    /**
+     * Construye cláusula WHERE a partir de condiciones
+     * @private
+     */
+    _buildWhereClause(conditions) {
+        if (!conditions || Object.keys(conditions).length === 0) {
+            return { clause: '', params: [] };
+        }
+        
+        const clauses = [];
+        const params = [];
+        
+        for (const [key, value] of Object.entries(conditions)) {
+            if (typeof value === 'object' && value !== null) {
+                // Operadores especiales
+                if (value.$eq !== undefined) {
+                    clauses.push(`${key} = ?`);
+                    params.push(value.$eq);
+                } else if (value.$ne !== undefined) {
+                    clauses.push(`${key} != ?`);
+                    params.push(value.$ne);
+                } else if (value.$gt !== undefined) {
+                    clauses.push(`${key} > ?`);
+                    params.push(value.$gt);
+                } else if (value.$gte !== undefined) {
+                    clauses.push(`${key} >= ?`);
+                    params.push(value.$gte);
+                } else if (value.$lt !== undefined) {
+                    clauses.push(`${key} < ?`);
+                    params.push(value.$lt);
+                } else if (value.$lte !== undefined) {
+                    clauses.push(`${key} <= ?`);
+                    params.push(value.$lte);
+                } else if (value.$in !== undefined) {
+                    const placeholders = value.$in.map(() => '?').join(', ');
+                    clauses.push(`${key} IN (${placeholders})`);
+                    params.push(...value.$in);
+                } else if (value.$like !== undefined) {
+                    clauses.push(`${key} LIKE ?`);
+                    params.push(value.$like);
+                } else if (value.$between !== undefined && Array.isArray(value.$between)) {
+                    clauses.push(`${key} BETWEEN ? AND ?`);
+                    params.push(value.$between[0], value.$between[1]);
+                } else if (value.$not !== undefined) {
+                    clauses.push(`${key} != ?`);
+                    params.push(value.$not);
+                }
+            } else {
+                clauses.push(`${key} = ?`);
+                params.push(value);
+            }
+        }
+        
+        return {
+            clause: clauses.length > 0 ? `WHERE ${clauses.join(' AND ')}` : '',
+            params
+        };
+    }
+
+    /**
+     * Formatea respuesta como JSON limpio
+     * @private
+     */
+    _formatResponse(data, operation, table = null) {
+        if (!this.config.jsonResponse) return data;
+        
+        const response = {
+            success: true,
+            operation: operation,
+            timestamp: new Date().toISOString(),
+            data: data
+        };
+        
+        if (table) response.table = table;
+        
+        // Para operaciones de creación
+        if (operation === 'create' && data && data.id) {
+            response.message = `Registro creado con ID: ${data.id}`;
+            response.recordId = data.id;
+        }
+        
+        // Para operaciones de actualización/eliminación
+        if (operation === 'update' && data.changes !== undefined) {
+            response.message = `Registros actualizados: ${data.changes}`;
+            response.changes = data.changes;
+        }
+        
+        if (operation === 'delete' && data.deleted !== undefined) {
+            response.message = `Registros eliminados: ${data.deleted}`;
+            response.deleted = data.deleted;
+        }
+        
+        // Para operaciones de lectura
+        if (operation === 'read' || operation === 'search') {
+            response.count = Array.isArray(data) ? data.length : 1;
+            response.message = `Registros encontrados: ${response.count}`;
+        }
+        
+        return response;
+    }
+
+    /**
+     * Crea uno o múltiples registros
+     * @param {string} table - Nombre de la tabla
+     * @param {Object|Array} data - Datos a insertar
+     * @returns {Object} - Respuesta JSON con registro(s) creado(s)
+     */
+    create(table, data) {
+        try {
+            // Crear tabla si no existe
+            if (!this.tableExists(table)) {
+                const sampleData = Array.isArray(data) ? data[0] : data;
+                this._autoCreateTable(table, sampleData);
+            }
+            
+            const isArray = Array.isArray(data);
+            const records = isArray ? data : [data];
+            const results = [];
+            
+            for (const record of records) {
+                const filtered = {};
+                for (const [key, value] of Object.entries(record)) {
+                    if (value !== undefined) filtered[key] = value;
+                }
+                
+                const keys = Object.keys(filtered);
+                const values = Object.values(filtered);
+                const placeholders = keys.map(() => '?').join(', ');
+                
+                const sql = `INSERT INTO ${table} (${keys.join(', ')}) VALUES (${placeholders})`;
+                if (this.config.verbose) console.log(`SQL: ${sql}`, values);
+                
+                const stmt = this.db.prepare(sql);
+                const result = stmt.run(...values);
+                
+                const newRecord = {
+                    id: result.lastInsertRowid,
+                    ...filtered,
+                    created_at: new Date().toISOString()
+                };
+                
+                results.push(newRecord);
+            }
+            
+            const responseData = isArray ? results : results[0];
+            return this._formatResponse(responseData, 'create', table);
+            
+        } catch (error) {
+            return {
+                success: false,
+                operation: 'create',
+                error: error.message,
+                timestamp: new Date().toISOString()
+            };
+        }
+    }
+
+    /**
+     * Lee registros de una tabla
+     * @param {string} table - Nombre de la tabla
+     * @param {Object} [conditions={}] - Condiciones de filtro
+     * @param {Object} [options={}] - Opciones de consulta
+     * @param {string} [options.orderBy] - Campo para ordenar
+     * @param {string} [options.order='ASC'] - Dirección del orden
+     * @param {number} [options.limit] - Límite de resultados
+     * @param {number} [options.offset] - Desplazamiento
+     * @returns {Object} - Respuesta JSON con registros encontrados
+     */
+    read(table, conditions = {}, options = {}) {
+        try {
+            if (!this.tableExists(table)) {
+                return this._formatResponse([], 'read', table);
+            }
+            
+            const { clause, params } = this._buildWhereClause(conditions);
+            let sql = `SELECT * FROM ${table} ${clause}`;
+            
+            if (options.orderBy) {
+                sql += ` ORDER BY ${options.orderBy} ${options.order || 'ASC'}`;
+            }
+            
+            if (options.limit) {
+                sql += ` LIMIT ${options.limit}`;
+            }
+            
+            if (options.offset) {
+                sql += ` OFFSET ${options.offset}`;
+            }
+            
+            if (this.config.verbose) console.log(`SQL: ${sql}`, params);
+            
+            const stmt = this.db.prepare(sql);
+            const results = stmt.all(...params);
+            
+            return this._formatResponse(results, 'read', table);
+            
+        } catch (error) {
+            return {
+                success: false,
+                operation: 'read',
+                error: error.message,
+                timestamp: new Date().toISOString()
+            };
+        }
+    }
+
+    /**
+     * Lee un solo registro
+     * @param {string} table - Nombre de la tabla
+     * @param {Object} [conditions={}] - Condiciones de filtro
+     * @returns {Object} - Respuesta JSON con registro encontrado o null
+     */
+    readOne(table, conditions = {}) {
+        try {
+            const result = this.read(table, conditions, { limit: 1 });
+            if (result.success && Array.isArray(result.data)) {
+                result.data = result.data[0] || null;
+                result.count = result.data ? 1 : 0;
+                result.message = result.data ? 'Registro encontrado' : 'No se encontró el registro';
+            }
+            return result;
+        } catch (error) {
+            return {
+                success: false,
+                operation: 'readOne',
+                error: error.message,
+                timestamp: new Date().toISOString()
+            };
+        }
+    }
+
+    /**
+     * Actualiza registros
+     * @param {string} table - Nombre de la tabla
+     * @param {Object} conditions - Condiciones para seleccionar registros
+     * @param {Object} data - Datos a actualizar
+     * @returns {Object} - Respuesta JSON con resultado de la operación
+     */
+    update(table, conditions, data) {
+        try {
+            if (!this.tableExists(table)) {
+                throw new Error(`La tabla '${table}' no existe`);
+            }
+            
+            const updateData = {};
+            for (const [key, value] of Object.entries(data)) {
+                if (value !== undefined) updateData[key] = value;
+            }
+            
+            if (Object.keys(updateData).length === 0) {
+                throw new Error('No hay datos para actualizar');
+            }
+            
+            const setClause = Object.keys(updateData)
+                .map(key => `${key} = ?`)
+                .join(', ');
+            
+            const { clause: whereClause, params: whereParams } = this._buildWhereClause(conditions);
+            
+            if (!whereClause) {
+                throw new Error('Se requieren condiciones para actualizar');
+            }
+            
+            const params = [
+                ...Object.values(updateData),
+                ...whereParams
+            ];
+            
+            const sql = `UPDATE ${table} SET ${setClause} ${whereClause}`;
+            if (this.config.verbose) console.log(`SQL: ${sql}`, params);
+            
+            const stmt = this.db.prepare(sql);
+            const result = stmt.run(...params);
+            
+            const responseData = {
+                changes: result.changes,
+                message: `Actualizados ${result.changes} registro(s)`
+            };
+            
+            return this._formatResponse(responseData, 'update', table);
+            
+        } catch (error) {
+            return {
+                success: false,
+                operation: 'update',
+                error: error.message,
+                timestamp: new Date().toISOString()
+            };
+        }
+    }
+
+    /**
+     * Elimina registros
+     * @param {string} table - Nombre de la tabla
+     * @param {Object} conditions - Condiciones para seleccionar registros
+     * @returns {Object} - Respuesta JSON con resultado de la operación
+     */
+    delete(table, conditions) {
+        try {
+            if (!this.tableExists(table)) {
+                throw new Error(`La tabla '${table}' no existe`);
+            }
+            
+            const { clause, params } = this._buildWhereClause(conditions);
+            
+            if (!clause) {
+                throw new Error('Se requieren condiciones para eliminar');
+            }
+            
+            const sql = `DELETE FROM ${table} ${clause}`;
+            if (this.config.verbose) console.log(`SQL: ${sql}`, params);
+            
+            const stmt = this.db.prepare(sql);
+            const result = stmt.run(...params);
+            
+            const responseData = {
+                deleted: result.changes,
+                message: `Eliminados ${result.changes} registro(s)`
+            };
+            
+            return this._formatResponse(responseData, 'delete', table);
+            
+        } catch (error) {
+            return {
+                success: false,
+                operation: 'delete',
+                error: error.message,
+                timestamp: new Date().toISOString()
+            };
+        }
+    }
+
+    /**
+     * Busca registros por texto
+     * @param {string} table - Nombre de la tabla
+     * @param {string|Array} fields - Campo(s) donde buscar
+     * @param {string} searchTerm - Término de búsqueda
+     * @returns {Object} - Respuesta JSON con registros encontrados
+     */
+    search(table, fields, searchTerm) {
+        try {
+            if (!this.tableExists(table)) {
+                return this._formatResponse([], 'search', table);
+            }
+            
+            const fieldList = Array.isArray(fields) ? fields : [fields];
+            const conditions = fieldList.map(field => `${field} LIKE ?`).join(' OR ');
+            const params = fieldList.map(() => `%${searchTerm}%`);
+            
+            const sql = `SELECT * FROM ${table} WHERE ${conditions}`;
+            if (this.config.verbose) console.log(`SQL: ${sql}`, params);
+            
+            const stmt = this.db.prepare(sql);
+            const results = stmt.all(...params);
+            
+            return this._formatResponse(results, 'search', table);
+            
+        } catch (error) {
+            return {
+                success: false,
+                operation: 'search',
+                error: error.message,
+                timestamp: new Date().toISOString()
+            };
+        }
+    }
+
+    /**
+     * Cuenta registros
+     * @param {string} table - Nombre de la tabla
+     * @param {Object} [conditions={}] - Condiciones de filtro
+     * @returns {Object} - Respuesta JSON con cantidad de registros
+     */
+    count(table, conditions = {}) {
+        try {
+            if (!this.tableExists(table)) {
+                return {
+                    success: true,
+                    operation: 'count',
+                    count: 0,
+                    message: 'La tabla no existe',
+                    timestamp: new Date().toISOString()
+                };
+            }
+            
+            const { clause, params } = this._buildWhereClause(conditions);
+            const sql = `SELECT COUNT(*) as total FROM ${table} ${clause}`;
+            if (this.config.verbose) console.log(`SQL: ${sql}`, params);
+            
+            const stmt = this.db.prepare(sql);
+            const result = stmt.get(...params);
+            const count = result ? result.total : 0;
+            
+            return {
+                success: true,
+                operation: 'count',
+                count: count,
+                message: `Total de registros: ${count}`,
+                timestamp: new Date().toISOString()
+            };
+            
+        } catch (error) {
+            return {
+                success: false,
+                operation: 'count',
+                error: error.message,
+                timestamp: new Date().toISOString()
+            };
+        }
+    }
+
+    /**
+     * Ejecuta una consulta SQL personalizada
+     * @param {string} sql - Consulta SQL
+     * @param {Array} [params=[]] - Parámetros para la consulta
+     * @returns {Object} - Respuesta JSON con resultado de la consulta
+     */
+    query(sql, params = []) {
+        try {
+            const stmt = this.db.prepare(sql);
+            const isSelect = sql.trim().toUpperCase().startsWith('SELECT');
+            
+            if (this.config.verbose) console.log(`SQL: ${sql}`, params);
+            
+            if (isSelect) {
+                const results = stmt.all(...params);
+                return {
+                    success: true,
+                    operation: 'query',
+                    type: 'SELECT',
+                    data: results,
+                    count: results.length,
+                    message: `Consulta ejecutada: ${results.length} resultados`,
+                    timestamp: new Date().toISOString()
+                };
+            } else {
+                const result = stmt.run(...params);
+                return {
+                    success: true,
+                    operation: 'query',
+                    type: 'EXECUTE',
+                    changes: result.changes,
+                    lastInsertRowid: result.lastInsertRowid,
+                    message: `Consulta ejecutada: ${result.changes} cambios`,
+                    timestamp: new Date().toISOString()
+                };
+            }
+            
+        } catch (error) {
+            return {
+                success: false,
+                operation: 'query',
+                error: error.message,
+                timestamp: new Date().toISOString()
+            };
+        }
+    }
+
+    /**
+     * Ejecuta operaciones en una transacción
+     * @param {Function} operations - Función con operaciones a ejecutar
+     * @returns {Object} - Respuesta JSON con resultado de la transacción
+     */
+    transaction(operations) {
+        try {
+            this.db.exec('BEGIN TRANSACTION');
+            let result;
+            
+            try {
+                result = operations(this);
+                this.db.exec('COMMIT');
+                return {
+                    success: true,
+                    operation: 'transaction',
+                    data: result,
+                    message: 'Transacción completada exitosamente',
+                    timestamp: new Date().toISOString()
+                };
+            } catch (error) {
+                this.db.exec('ROLLBACK');
+                throw error;
+            }
+            
+        } catch (error) {
+            return {
+                success: false,
+                operation: 'transaction',
+                error: error.message,
+                timestamp: new Date().toISOString()
+            };
+        }
+    }
+
+    /**
+     * Lista todas las tablas
+     * @returns {Object} - Respuesta JSON con nombres de las tablas
+     */
+    listTables() {
+        try {
+            const sql = `
+                SELECT name FROM sqlite_master 
+                WHERE type='table' 
+                AND name NOT LIKE 'sqlite_%'
+                AND name NOT LIKE '_easydb_%'
+                ORDER BY name
+            `;
+            const stmt = this.db.prepare(sql);
+            const tables = stmt.all().map(table => table.name);
+            
+            return {
+                success: true,
+                operation: 'listTables',
+                tables: tables,
+                count: tables.length,
+                message: `Tablas encontradas: ${tables.length}`,
+                timestamp: new Date().toISOString()
+            };
+        } catch (error) {
+            return {
+                success: false,
+                operation: 'listTables',
+                error: error.message,
+                timestamp: new Date().toISOString()
+            };
+        }
+    }
+
+    /**
+     * Obtiene información de una tabla
+     * @param {string} table - Nombre de la tabla
+     * @returns {Object} - Respuesta JSON con información de columnas
+     */
+    tableInfo(table) {
+        try {
+            if (!this.tableExists(table)) {
+                throw new Error(`La tabla '${table}' no existe`);
+            }
+            
+            const sql = `PRAGMA table_info(${table})`;
+            const stmt = this.db.prepare(sql);
+            const columns = stmt.all();
+            
+            return {
+                success: true,
+                operation: 'tableInfo',
+                table: table,
+                columns: columns,
+                count: columns.length,
+                message: `Columnas en ${table}: ${columns.length}`,
+                timestamp: new Date().toISOString()
+            };
+        } catch (error) {
+            return {
+                success: false,
+                operation: 'tableInfo',
+                error: error.message,
+                timestamp: new Date().toISOString()
+            };
+        }
+    }
+
+    /**
+     * Exporta toda la base de datos a JSON
+     * @returns {Object} - Respuesta JSON con datos exportados
+     */
+    exportToJSON() {
+        try {
+            const tablesResult = this.listTables();
+            if (!tablesResult.success) throw new Error(tablesResult.error);
+            
+            const tables = tablesResult.tables;
+            const exportData = {};
+            
+            for (const table of tables) {
+                const result = this.read(table);
+                if (result.success) {
+                    exportData[table] = result.data;
+                }
+            }
+            
+            return {
+                success: true,
+                operation: 'exportToJSON',
+                metadata: {
+                    exported_at: new Date().toISOString(),
+                    version: this._getMeta('version'),
+                    tables: tables.length
+                },
+                data: exportData,
+                message: `Base de datos exportada: ${tables.length} tablas`,
+                timestamp: new Date().toISOString()
+            };
+        } catch (error) {
+            return {
+                success: false,
+                operation: 'exportToJSON',
+                error: error.message,
+                timestamp: new Date().toISOString()
+            };
+        }
+    }
+
+    /**
+     * Importa datos desde JSON
+     * @param {Object} data - Datos a importar
+     * @returns {Object} - Respuesta JSON con resultado de la importación
+     */
+    importFromJSON(data) {
+        try {
+            let imported = 0;
+            let created = 0;
+            
+            for (const [table, records] of Object.entries(data)) {
+                if (!this.tableExists(table) && records.length > 0) {
+                    this._autoCreateTable(table, records[0]);
+                    created++;
+                }
+                
+                for (const record of records) {
+                    const result = this.create(table, record);
+                    if (result.success) imported++;
+                }
+            }
+            
+            return {
+                success: true,
+                operation: 'importFromJSON',
+                imported: imported,
+                tables_created: created,
+                message: `Importados ${imported} registros, creadas ${created} tablas`,
+                timestamp: new Date().toISOString()
+            };
+        } catch (error) {
+            return {
+                success: false,
+                operation: 'importFromJSON',
+                error: error.message,
+                timestamp: new Date().toISOString()
+            };
+        }
+    }
+
+    /**
+     * Crea un backup de la base de datos
+     * @param {string} [backupPath] - Ruta para el backup
+     * @returns {Object} - Respuesta JSON con resultado del backup
+     */
+    backup(backupPath) {
+        try {
+            const defaultPath = `backup_${Date.now()}.db`;
+            const targetPath = backupPath || defaultPath;
+            
+            // Asegurar que el directorio del backup existe
+            ensureDirectoryExists(targetPath);
+            
+            if (this.config.memory) {
+                const jsonData = this.exportToJSON();
+                fs.writeFileSync(
+                    targetPath.replace('.db', '.json'),
+                    JSON.stringify(jsonData, null, 2)
+                );
+                
+                return {
+                    success: true,
+                    operation: 'backup',
+                    path: path.resolve(targetPath.replace('.db', '.json')),
+                    format: 'json',
+                    message: 'Backup en memoria exportado a JSON',
+                    timestamp: new Date().toISOString()
+                };
+            }
+            
+            fs.copyFileSync(this.config.filename, targetPath);
+            
+            return {
+                success: true,
+                operation: 'backup',
+                path: path.resolve(targetPath),
+                format: 'sqlite',
+                size: fs.statSync(targetPath).size,
+                message: 'Backup de base de datos creado',
+                timestamp: new Date().toISOString()
+            };
+            
+        } catch (error) {
+            return {
+                success: false,
+                operation: 'backup',
+                error: error.message,
+                timestamp: new Date().toISOString()
+            };
+        }
+    }
+
+    /**
+     * Cierra la conexión a la base de datos
+     * @returns {Object} - Respuesta JSON de confirmación
+     */
+    close() {
+        try {
+            this.db.close();
+            return {
+                success: true,
+                operation: 'close',
+                message: 'Conexión cerrada exitosamente',
+                timestamp: new Date().toISOString()
+            };
+        } catch (error) {
+            return {
+                success: false,
+                operation: 'close',
+                error: error.message,
+                timestamp: new Date().toISOString()
+            };
+        }
+    }
+
+    /**
+     * Obtiene estadísticas de la base de datos
+     * @returns {Object} - Respuesta JSON con estadísticas
+     */
+    getStats() {
+        try {
+            const tablesResult = this.listTables();
+            if (!tablesResult.success) throw new Error(tablesResult.error);
+            
+            const tables = tablesResult.tables;
+            const stats = {
+                tables: tables.length,
+                total_records: 0,
+                table_stats: {}
+            };
+            
+            for (const table of tables) {
+                const countResult = this.count(table);
+                if (countResult.success) {
+                    stats.total_records += countResult.count;
+                    const infoResult = this.tableInfo(table);
+                    stats.table_stats[table] = {
+                        records: countResult.count,
+                        columns: infoResult.success ? infoResult.count : 0
+                    };
+                }
+            }
+            
+            return {
+                success: true,
+                operation: 'getStats',
+                stats: stats,
+                metadata: {
+                    filename: path.resolve(this.config.filename),
+                    memory: this.config.memory,
+                    version: this._getMeta('version'),
+                    created: this._getMeta('created_at')
+                },
+                message: `Estadísticas: ${stats.tables} tablas, ${stats.total_records} registros`,
+                timestamp: new Date().toISOString()
+            };
+        } catch (error) {
+            return {
+                success: false,
+                operation: 'getStats',
+                error: error.message,
+                timestamp: new Date().toISOString()
+            };
+        }
+    }
+
+    /**
+     * Obtiene información del archivo de la base de datos
+     * @returns {Object} - Información del archivo
+     */
+    getFileInfo() {
+        try {
+            if (this.config.memory) {
+                return {
+                    success: true,
+                    is_memory: true,
+                    message: 'Base de datos en memoria',
+                    timestamp: new Date().toISOString()
+                };
+            }
+            
+            const filePath = this.config.filename;
+            const exists = fs.existsSync(filePath);
+            const info = exists ? fs.statSync(filePath) : null;
+            
+            return {
+                success: true,
+                path: path.resolve(filePath),
+                exists: exists,
+                size: exists ? info.size : 0,
+                created: exists ? info.birthtime : null,
+                modified: exists ? info.mtime : null,
+                is_memory: false,
+                timestamp: new Date().toISOString()
+            };
+        } catch (error) {
+            return {
+                success: false,
+                error: error.message,
+                timestamp: new Date().toISOString()
+            };
+        }
+    }
+}
+
+// ======================
+// INSTANCIA GLOBAL
+// ======================
+
+/**
+ * Crea una instancia de EasyDB
+ * @param {string|Object} config - Configuración
+ * @returns {EasyDB} - Instancia de EasyDB
+ */
+function createInstance(config = DEFAULT_DB_PATH) {
+    return new EasyDB(config);
+}
+
+// Instancia global predeterminada
+const defaultInstance = createInstance();
+
+// API global para acceso rápido con respuestas JSON
+const db = {
+    // Operaciones básicas
+    create: (table, data) => defaultInstance.create(table, data),
+    read: (table, conditions, options) => defaultInstance.read(table, conditions, options),
+    readOne: (table, conditions) => defaultInstance.readOne(table, conditions),
+    update: (table, conditions, data) => defaultInstance.update(table, conditions, data),
+    delete: (table, conditions) => defaultInstance.delete(table, conditions),
+    
+    // Operaciones avanzadas
+    search: (table, fields, searchTerm) => defaultInstance.search(table, fields, searchTerm),
+    count: (table, conditions) => defaultInstance.count(table, conditions),
+    query: (sql, params) => defaultInstance.query(sql, params),
+    transaction: (operations) => defaultInstance.transaction(operations),
+    
+    // Nueva funcionalidad para agregar columnas
+    addColumn: (tableName, columnName, columnType, defaultValue) => 
+        defaultInstance.addColumn(tableName, columnName, columnType, defaultValue),
+    addColumns: (tableName, columns) => defaultInstance.addColumns(tableName, columns),
+    
+    // Metadatos y utilidades
+    listTables: () => defaultInstance.listTables(),
+    tableInfo: (table) => defaultInstance.tableInfo(table),
+    exportToJSON: () => defaultInstance.exportToJSON(),
+    importFromJSON: (data) => defaultInstance.importFromJSON(data),
+    backup: (backupPath) => defaultInstance.backup(backupPath),
+    close: () => defaultInstance.close(),
+    getStats: () => defaultInstance.getStats(),
+    getFileInfo: () => defaultInstance.getFileInfo(),
+    
+    // Información del sistema
+    getVersion: () => defaultInstance._getMeta('version'),
+    
+    // Crear nueva instancia
+    createInstance: (config) => createInstance(config),
+    
+    // Variables globales (exportadas para uso externo)
+    DB_PATH: DEFAULT_DB_PATH,
+    ensureDirectoryExists: ensureDirectoryExists,
+    
+    // Acceso directo a la instancia (opcional)
+    _instance: defaultInstance
+};
+
+module.exports = db;

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "andres-db",
+  "version": "2.2.0",
+  "description": "Interfaz JavaScript simplificada para bases de datos SQLite con respuestas JSON estructuradas",
+  "main": "index.js",
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "scripts": {
+    "start": "node index.js"
+  },
+  "keywords": [
+    "sqlite",
+    "database",
+    "json",
+    "crud",
+    "nodejs",
+    "andres-db",
+    "simpledb",
+    "db"
+  ],
+  "author": "ANDRES CARVAJAL OROZCO <https://andres-carvajal.vercel.app/>",
+  "license": "MIT",
+  "dependencies": {
+    "better-sqlite3": "^8.5.0"
+  },
+  "files": [
+    "index.js",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}