jerkjs 2.3.0 → 2.4.0

package/jerk-qbuilder/HOWTO.md

@@ -1,325 +0,0 @@
-# Cómo usar el QueryBuilder
-
-## Introducción
-
-El QueryBuilder es una herramienta poderosa para construir consultas SQL de manera segura y eficiente. Este documento explica cómo utilizarlo en diferentes escenarios, incluyendo su integración con middlewares y el sistema de hooks de JERK.
-
-## Instalación y configuración
-
-### 1. Importar el QueryBuilder
-
-```javascript
-const QueryBuilder = require('./path/to/queryBuilder');
-const MariaDBAdapter = require('./path/to/MariaDBAdapter');
-```
-
-### 2. Crear un adaptador
-
-```javascript
-// Adaptador para MariaDB
-const adapter = new MariaDBAdapter({
-  host: 'localhost',
-  user: 'root',
-  password: '',
-  database: 'my_database'
-});
-```
-
-## Uso básico
-
-### 1. Crear una instancia del QueryBuilder
-
-```javascript
-// Opción 1: Sin adaptador (solo para construir consultas)
-const qb = new QueryBuilder();
-
-// Opción 2: Con adaptador (para ejecutar consultas)
-const qb = new QueryBuilder(adapter);
-
-// Opción 3: Configurar adaptador después (método setAdapter())
-const qb = new QueryBuilder();
-qb.setAdapter(adapter);
-```
-
-### 2. Construir una consulta SELECT simple
-
-```javascript
-const result = await qb
-  .table('users')
-  .select('id', 'name', 'email')
-  .where('age', '>', 18)
-  .orderBy('name', 'ASC')
-  .limit(10)
-  .get();
-```
-
-### 3. Usar SELECT *
-
-```javascript
-// Para seleccionar todos los campos
-const result = await qb
-  .table('users')
-  .select('*')  // Esto funciona correctamente
-  .where('status', 'active')
-  .get();
-```
-
-## Operaciones CRUD
-
-### SELECT
-
-```javascript
-// Consulta básica
-const users = await qb
-  .table('users')
-  .select('id', 'name', 'email')
-  .where('active', true)
-  .get();
-
-// Obtener un solo registro
-const user = await qb
-  .table('users')
-  .select('*')
-  .where('id', 1)
-  .first();
-
-// Consulta con JOIN
-const result = await qb
-  .table('users')
-  .select('users.name', 'profiles.bio')
-  .join('profiles', 'users.id', '=', 'profiles.user_id')
-  .where('users.active', true)
-  .get();
-
-// Consulta con múltiples condiciones
-const result = await qb
-  .table('orders')
-  .select('*')
-  .where('status', 'completed')
-  .where('amount', '>', 100)
-  .whereBetween('created_at', '2023-01-01', '2023-12-31')
-  .get();
-```
-
-### INSERT
-
-```javascript
-const result = await qb
-  .table('users')
-  .insert({
-    name: 'John Doe',
-    email: 'john@example.com',
-    age: 30
-  });
-```
-
-### UPDATE
-
-```javascript
-const affectedRows = await qb
-  .table('users')
-  .where('id', 1)
-  .update({
-    name: 'Jane Doe',
-    email: 'jane@example.com'
-  });
-```
-
-### DELETE
-
-```javascript
-const affectedRows = await qb
-  .table('users')
-  .where('status', 'inactive')
-  .delete();
-```
-
-## Condiciones WHERE
-
-### WHERE simple
-```javascript
-qb.where('column', 'value')
-qb.where('column', '=', 'value')
-qb.where('column', '>', 18)
-```
-
-### WHERE con operadores
-```javascript
-qb.where('age', '>=', 18)
-qb.where('status', '!=', 'inactive')
-qb.where('name', 'LIKE', '%john%')
-```
-
-### WHERE IN
-```javascript
-qb.whereIn('id', [1, 2, 3, 4])
-qb.whereNotIn('category', ['deleted', 'spam'])
-```
-
-### WHERE BETWEEN
-```javascript
-qb.whereBetween('age', 18, 65)
-qb.whereNotBetween('amount', 100, 1000)
-```
-
-### Condiciones complejas
-```javascript
-qb.where(function(qb) {
-  qb.where('status', 'active')
-    .orWhere('premium', true);
-});
-```
-
-## Otras operaciones
-
-### Agrupamiento y ordenamiento
-```javascript
-qb.groupBy('category')
-qb.orderBy('created_at', 'DESC')
-qb.orderBy('name', 'ASC')
-```
-
-### Paginación
-```javascript
-qb.offset(10)
-qb.limit(20)
-```
-
-### Funciones de agregación
-```javascript
-// Contar registros
-const count = await qb.table('users').count();
-
-// Máximo valor
-const maxAge = await qb.table('users').max('age');
-
-// Mínimo valor
-const minAge = await qb.table('users').min('age');
-
-// Suma
-const totalAmount = await qb.table('orders').sum('amount');
-
-// Promedio
-const avgScore = await qb.table('students').avg('score');
-```
-
-## Uso con diferentes adaptadores
-
-### 1. Adaptador de MariaDB/MySQL
-```javascript
-const MariaDBAdapter = require('./MariaDBAdapter');
-
-const adapter = new MariaDBAdapter({
-  host: 'localhost',
-  user: 'root',
-  password: 'password',
-  database: 'myapp'
-});
-
-const qb = new QueryBuilder(adapter);
-```
-
-### 2. Adaptador de consola (para pruebas)
-```javascript
-const ConsoleAdapter = require('./ConsoleAdapter');
-
-const adapter = new ConsoleAdapter();
-const qb = new QueryBuilder(adapter);
-```
-
-### 3. Cambiar adaptador dinámicamente
-```javascript
-const qb = new QueryBuilder();
-
-// Más tarde en el código
-qb.setAdapter(mariaDBAdapter);
-// Ahora puede ejecutar consultas en la base de datos
-```
-
-## Integración con Middleware
-
-El QueryBuilder incluye un middleware para inyectar instancias del QueryBuilder en las solicitudes HTTP:
-
-```javascript
-const { APIServer } = require('jerkjs');
-const { QueryBuilderMiddleware } = require('./queryBuilderMiddleware');
-const MariaDBAdapter = require('./MariaDBAdapter');
-
-const server = new APIServer({ port: 3000 });
-
-// Crear middleware
-const qbMiddleware = new QueryBuilderMiddleware();
-const dbAdapter = new MariaDBAdapter(config);
-
-// Agregar middleware para inyectar QueryBuilder
-server.use(qbMiddleware.configureWithAdapter(dbAdapter));
-server.use(qbMiddleware.injectQueryBuilder.bind(qbMiddleware));
-
-// En un controlador
-app.addRoute('GET', '/users', async (req, res) => {
-  const users = await req.queryBuilder('users')
-    .select('*')
-    .where('active', true)
-    .get();
-    
-  res.json(users);
-});
-```
-
-## Integración con el sistema de Hooks de JERK
-
-Cuando se usa con el framework JERK, el QueryBuilder se puede integrar con el sistema de hooks:
-
-```javascript
-const { hooks } = require('jerkjs');
-const { initializeQueryBuilderHooks, extendQueryBuilderWithHooks } = require('./queryBuilderHooks');
-
-// Inicializar hooks
-initializeQueryBuilderHooks(hooks);
-extendQueryBuilderWithHooks(QueryBuilder, hooks);
-```
-
-## Ejemplo completo
-
-```javascript
-const QueryBuilder = require('./queryBuilder');
-const MariaDBAdapter = require('./MariaDBAdapter');
-
-// Crear adaptador
-const dbAdapter = new MariaDBAdapter({
-  host: 'localhost',
-  user: 'root',
-  password: '',
-  database: 'otrack_db'
-});
-
-// Crear QueryBuilder
-const qb = new QueryBuilder(dbAdapter);
-
-// Ejemplo de uso: obtener usuarios activos con ciertos criterios
-try {
-  const users = await qb
-    .table('users')
-    .select('id', 'name', 'email', 'created_at')
-    .where('status', 'active')
-    .where('created_at', '>', '2023-01-01')
-    .whereIn('role', ['admin', 'editor'])
-    .orderBy('created_at', 'DESC')
-    .limit(50)
-    .get();
-
-  console.log(`Encontrados ${users.length} usuarios`);
-} catch (error) {
-  console.error('Error en la consulta:', error.message);
-}
-```
-
-## Consejos de seguridad
-
-1. **Siempre use parámetros**: El QueryBuilder utiliza placeholders (`?`) para prevenir inyección SQL
-2. **Valide entradas**: Aunque el QueryBuilder ayuda con la seguridad, siempre valide y sane las entradas del usuario
-3. **Use setAdapter() cuidadosamente**: Asegúrese de que los adaptadores provengan de fuentes confiables
-
-## Resumen
-
-El QueryBuilder proporciona una forma segura y fluida de construir consultas SQL. Con su método `setAdapter()`, puede trabajar con cualquier base de datos, y su API intuitiva facilita la creación de consultas complejas. Además, incluye middleware para integración fácil con frameworks web y soporte para el sistema de hooks de JERK.

package/jerk-qbuilder/README.md

@@ -1,52 +0,0 @@
-# QueryBuilder para JERK Framework
-
-## Descripción
-
-QueryBuilder es una biblioteca independiente para construir consultas SQL de manera fluida y segura. Está diseñada para trabajar con el framework JERK pero puede utilizarse de forma independiente con cualquier sistema Node.js.
-
-## Características
-
-- **API fluida**: Construcción intuitiva de consultas SQL
-- **Seguridad**: Prevención de inyección SQL mediante el uso de parámetros
-- **Flexibilidad**: Compatible con múltiples adaptadores de base de datos
-- **Método setAdapter()**: Permite configurar dinámicamente cualquier adaptador
-- **Soporte para múltiples bases de datos**: MariaDB, MySQL, PostgreSQL, SQLite, etc.
-- **Middleware de integración**: Sistema completo para inyectar QueryBuilder en solicitudes HTTP
-- **Integración con hooks**: Compatible con el sistema de hooks y filters de JERK
-
-## Componentes
-
-- `queryBuilder.js`: El QueryBuilder principal con todos sus métodos
-- `MariaDBAdapter.js`: Adaptador para conexión con bases de datos MariaDB/MySQL
-- `ConsoleAdapter.js`: Adaptador de ejemplo para mostrar consultas por consola
-- `queryBuilderHooks.js`: Sistema de integración con los hooks y filters de JERK
-- `queryBuilderMiddleware.js`: Middleware para integrar el QueryBuilder con el framework
-
-## Instalación
-
-Simplemente copie los archivos del QueryBuilder a su proyecto y utilice los módulos según sus necesidades.
-
-## Uso básico
-
-```javascript
-const QueryBuilder = require('./queryBuilder');
-const MariaDBAdapter = require('./MariaDBAdapter');
-
-// Crear adaptador
-const adapter = new MariaDBAdapter({
-  host: 'localhost',
-  user: 'root',
-  password: '',
-  database: 'my_database'
-});
-
-// Crear QueryBuilder con adaptador
-const qb = new QueryBuilder(adapter);
-
-// Usar el QueryBuilder
-const results = await qb
-  .table('users')
-  .select('id', 'name', 'email')
-  .where('active', true)
-  .get();
-```

package/lib/query/MariaDBAdapter.js

@@ -1,78 +0,0 @@
-/**
- * Adaptador de MariaDB para el QueryBuilder
- * MariaDBAdapter.js
- * 
- * Este adaptador simplemente ejecuta las consultas SQL construidas por el QueryBuilder
- */
-
-const mariadb = require('mariadb');
-
-class MariaDBAdapter {
-  /**
-   * Constructor del adaptador MariaDB
-   * @param {Object} options - Opciones de configuración
-   */
-  constructor(options = {}) {
-    // Configuración de la conexión a la base de datos
-    this.dbConfig = {
-      host: options.host || 'localhost',
-      user: options.user || 'root',
-      password: options.password || '',
-      database: options.database || 'otrack_db',
-      waitForConnections: options.waitForConnections !== false,
-      connectionLimit: options.connectionLimit || 10,
-      queueLimit: options.queueLimit || 0,
-      acquireTimeout: options.acquireTimeout || 60000,
-      timeout: options.timeout || 60000,
-      ...options
-    };
-
-    // Crear pool de conexiones
-    this.pool = mariadb.createPool(this.dbConfig);
-  }
-
-  /**
-   * Método para ejecutar una consulta SQL
-   * @param {string} sql - Consulta SQL construida por el QueryBuilder
-   * @param {Array} params - Parámetros de la consulta
-   * @returns {Promise<Object>} - Resultado de la consulta
-   */
-  async query(sql, params = []) {
-    const connection = await this.pool.getConnection();
-    try {
-      return await connection.query(sql, params);
-    } catch (error) {
-      throw error;
-    } finally {
-      connection.release();
-    }
-  }
-
-  /**
-   * Método para cerrar la conexión
-   */
-  async close() {
-    try {
-      await this.pool.end();
-      console.log('Conexión a MariaDB cerrada correctamente');
-    } catch (error) {
-      console.error('Error al cerrar la conexión a MariaDB:', error.message);
-    }
-  }
-
-  /**
-   * Método para verificar si el adaptador está conectado
-   * @returns {Promise<boolean>} - Verdadero si está conectado
-   */
-  async isConnected() {
-    try {
-      const connection = await this.pool.getConnection();
-      connection.release();
-      return true;
-    } catch (error) {
-      return false;
-    }
-  }
-}
-
-module.exports = MariaDBAdapter;

package/lib/query/consoleAdapter.js

@@ -1,184 +0,0 @@
-/**
- * Adaptador de ejemplo para mostrar consultas SQL por consola
- * ConsoleAdapter.js
- */
-
-class ConsoleAdapter {
-  constructor(options = {}) {
-    this.options = options;
-    this.queriesExecuted = 0;
-  }
-
-  /**
-   * Método para ejecutar una consulta
-   * @param {string} sql - Consulta SQL
-   * @param {Array} params - Parámetros de la consulta
-   * @returns {Promise<Object>} - Resultado simulado
-   */
-  async query(sql, params = []) {
-    this.queriesExecuted++;
-    
-    console.log(`\n--- CONSULTA #${this.queriesExecuted} ---`);
-    console.log(`SQL: ${sql}`);
-    console.log(`Parámetros:`, params);
-    console.log('--- FIN CONSULTA ---\n');
-    
-    // Simular un resultado dependiendo del tipo de consulta
-    if (sql.trim().toUpperCase().startsWith('SELECT')) {
-      // Para consultas SELECT, devolver un array vacío o con datos simulados
-      return [];
-    } else if (sql.trim().toUpperCase().startsWith('INSERT')) {
-      // Para INSERT, simular un ID insertado
-      return { insertId: Math.floor(Math.random() * 10000), affectedRows: 1 };
-    } else if (sql.trim().toUpperCase().startsWith('UPDATE') || sql.trim().toUpperCase().startsWith('DELETE')) {
-      // Para UPDATE/DELETE, simular filas afectadas
-      return { affectedRows: Math.floor(Math.random() * 5) + 1 };
-    } else {
-      // Para otros tipos de consulta, devolver un objeto vacío
-      return {};
-    }
-  }
-
-  /**
-   * Método para crear un registro
-   * @param {string} tableName - Nombre de la tabla
-   * @param {Object} data - Datos a insertar
-   * @returns {Promise<Object>} - Resultado simulado
-   */
-  async create(tableName, data) {
-    const columns = Object.keys(data).join(', ');
-    const placeholders = Object.keys(data).map(() => '?').join(', ');
-    const sql = `INSERT INTO \`${tableName}\` (${columns}) VALUES (${placeholders})`;
-    const params = Object.values(data);
-    
-    return await this.query(sql, params);
-  }
-
-  /**
-   * Método para encontrar registros
-   * @param {string} tableName - Nombre de la tabla
-   * @param {Object} conditions - Condiciones de búsqueda
-   * @param {Object} options - Opciones adicionales
-   * @returns {Promise<Array>} - Resultados simulados
-   */
-  async find(tableName, conditions, options = {}) {
-    let sql = `SELECT * FROM \`${tableName}\``;
-    const params = [];
-    
-    if (conditions && Object.keys(conditions).length > 0) {
-      const conditionsList = [];
-      for (const [key, value] of Object.entries(conditions)) {
-        if (value !== undefined && value !== null) {
-          conditionsList.push(`${key} = ?`);
-          params.push(value);
-        }
-      }
-      if (conditionsList.length > 0) {
-        sql += ' WHERE ' + conditionsList.join(' AND ');
-      }
-    }
-    
-    return await this.query(sql, params);
-  }
-
-  /**
-   * Método para encontrar un solo registro
-   * @param {string} tableName - Nombre de la tabla
-   * @param {Object} conditions - Condiciones de búsqueda
-   * @param {Object} options - Opciones adicionales
-   * @returns {Promise<Object|null>} - Resultado simulado o null
-   */
-  async findOne(tableName, conditions, options = {}) {
-    const results = await this.find(tableName, conditions, { ...options, limit: 1 });
-    return results.length > 0 ? results[0] : null;
-  }
-
-  /**
-   * Método para actualizar registros
-   * @param {string} tableName - Nombre de la tabla
-   * @param {Object} conditions - Condiciones para seleccionar registros
-   * @param {Object} data - Datos a actualizar
-   * @returns {Promise<number>} - Número de filas afectadas simuladas
-   */
-  async update(tableName, conditions, data) {
-    const dataEntries = Object.entries(data);
-    if (dataEntries.length === 0) {
-      return 0;
-    }
-
-    const setClause = dataEntries.map(([key]) => `${key} = ?`).join(', ');
-    const params = dataEntries.map(([, value]) => value);
-
-    const whereClause = [];
-    for (const [key, value] of Object.entries(conditions)) {
-      if (value !== undefined && value !== null) {
-        whereClause.push(`${key} = ?`);
-        params.push(value);
-      }
-    }
-
-    let sql = `UPDATE \`${tableName}\` SET ${setClause}`;
-    if (whereClause.length > 0) {
-      sql += ' WHERE ' + whereClause.join(' AND ');
-    }
-
-    const result = await this.query(sql, params);
-    return result.affectedRows || 0;
-  }
-
-  /**
-   * Método para eliminar registros
-   * @param {string} tableName - Nombre de la tabla
-   * @param {Object} conditions - Condiciones para seleccionar registros
-   * @returns {Promise<number>} - Número de filas afectadas simuladas
-   */
-  async delete(tableName, conditions) {
-    let sql = `DELETE FROM \`${tableName}\``;
-    const params = [];
-
-    if (conditions && Object.keys(conditions).length > 0) {
-      const conditionsList = [];
-      for (const [key, value] of Object.entries(conditions)) {
-        if (value !== undefined && value !== null) {
-          conditionsList.push(`${key} = ?`);
-          params.push(value);
-        }
-      }
-      if (conditionsList.length > 0) {
-        sql += ' WHERE ' + conditionsList.join(' AND ');
-      }
-    }
-
-    const result = await this.query(sql, params);
-    return result.affectedRows || 0;
-  }
-
-  /**
-   * Método para contar registros
-   * @param {string} tableName - Nombre de la tabla
-   * @param {Object} conditions - Condiciones de conteo
-   * @returns {Promise<number>} - Número simulado de registros
-   */
-  async count(tableName, conditions) {
-    let sql = `SELECT COUNT(*) as total FROM \`${tableName}\``;
-    const params = [];
-
-    if (conditions && Object.keys(conditions).length > 0) {
-      const conditionsList = [];
-      for (const [key, value] of Object.entries(conditions)) {
-        if (value !== undefined && value !== null) {
-          conditionsList.push(`${key} = ?`);
-          params.push(value);
-        }
-      }
-      if (conditionsList.length > 0) {
-        sql += ' WHERE ' + conditionsList.join(' AND ');
-      }
-    }
-
-    const result = await this.query(sql, params);
-    return result[0] ? result[0].total : 0;
-  }
-}
-
-module.exports = ConsoleAdapter;