jerkjs 2.1.6 → 2.2.0

package/lib/mvc/MariaDBAdapter.js

@@ -0,0 +1,315 @@
+/**
+ * Adaptador de MariaDB para modelos en el framework JERK
+ * Implementación del componente MVC MariaDBAdapter.js
+ * Proporciona acceso a bases de datos MariaDB/MySQL
+ */
+
+const GenericAdapter = require('../../lib/mvc/GenericAdapter');
+const mariadb = require('mariadb');
+
+class MariaDBAdapter extends GenericAdapter {
+  /**
+   * Constructor del adaptador MariaDB
+   * @param {Object} options - Opciones de configuración
+   */
+  constructor(options = {}) {
+    super({ ...options, type: 'mariadb' });
+    
+    // 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,
+      ...options
+    };
+    
+    // Crear pool de conexiones
+    this.pool = mariadb.createPool(this.dbConfig);
+  }
+
+  /**
+   * Método para crear un registro
+   * @param {string} tableName - Nombre de la tabla
+   * @param {Object} data - Datos a crear
+   * @returns {Promise<Object>} - Promesa con el resultado
+   */
+  async create(tableName, data) {
+    const columns = Object.keys(data).join(', ');
+    const placeholders = Object.keys(data).map(() => '?').join(', ');
+    const query = `INSERT INTO ${tableName} (${columns}) VALUES (${placeholders})`;
+    const params = Object.values(data);
+
+    const connection = await this.pool.getConnection();
+    try {
+      const result = await connection.query(query, params);
+      
+      // Obtener el registro recién insertado
+      const insertedRecord = await connection.query(
+        `SELECT * FROM ${tableName} WHERE id = ?`, 
+        [result.insertId]
+      );
+      
+      return insertedRecord[0] || { id: result.insertId, ...data };
+    } finally {
+      connection.release();
+    }
+  }
+
+  /**
+   * 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>} - Promesa con los resultados
+   */
+  async find(tableName, conditions, options = {}) {
+    let query = `SELECT * FROM ${tableName}`;
+    const params = [];
+
+    // Añadir condiciones WHERE
+    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) {
+        query += ' WHERE ' + conditionsList.join(' AND ');
+      }
+    }
+
+    // Añadir ordenamiento
+    if (options.orderBy) {
+      query += ` ORDER BY ${options.orderBy}`;
+    }
+
+    // Añadir paginación
+    if (options.limit) {
+      query += ` LIMIT `;
+      if (options.offset) {
+        query += `${options.offset}, `;
+      }
+      query += options.limit;
+    }
+
+    const connection = await this.pool.getConnection();
+    try {
+      return await connection.query(query, params);
+    } finally {
+      connection.release();
+    }
+  }
+
+  /**
+   * 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>} - Promesa con el resultado 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>} - Promesa con el número de registros afectados
+   */
+  async update(tableName, conditions, data) {
+    const dataEntries = Object.entries(data);
+    if (dataEntries.length === 0) {
+      return 0; // No hay nada que actualizar
+    }
+
+    // Construir la parte SET de la consulta
+    const setClause = dataEntries.map(([key]) => `${key} = ?`).join(', ');
+    const params = dataEntries.map(([, value]) => value);
+
+    // Construir la parte WHERE de la consulta
+    const whereClause = [];
+    for (const [key, value] of Object.entries(conditions)) {
+      if (value !== undefined && value !== null) {
+        whereClause.push(`${key} = ?`);
+        params.push(value);
+      }
+    }
+
+    let query = `UPDATE ${tableName} SET ${setClause}`;
+    if (whereClause.length > 0) {
+      query += ` WHERE ${whereClause.join(' AND ')}`;
+    }
+
+    const connection = await this.pool.getConnection();
+    try {
+      const result = await connection.query(query, params);
+      return result.affectedRows;
+    } finally {
+      connection.release();
+    }
+  }
+
+  /**
+   * Método para eliminar registros
+   * @param {string} tableName - Nombre de la tabla
+   * @param {Object} conditions - Condiciones para seleccionar registros
+   * @returns {Promise<number>} - Promesa con el número de registros eliminados
+   */
+  async delete(tableName, conditions) {
+    let query = `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) {
+        query += ' WHERE ' + conditionsList.join(' AND ');
+      }
+    }
+
+    const connection = await this.pool.getConnection();
+    try {
+      const result = await connection.query(query, params);
+      return result.affectedRows;
+    } finally {
+      connection.release();
+    }
+  }
+
+  /**
+   * Método para contar registros
+   * @param {string} tableName - Nombre de la tabla
+   * @param {Object} conditions - Condiciones de conteo
+   * @returns {Promise<number>} - Promesa con el número de registros
+   */
+  async count(tableName, conditions) {
+    let query = `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) {
+        query += ' WHERE ' + conditionsList.join(' AND ');
+      }
+    }
+
+    const connection = await this.pool.getConnection();
+    try {
+      const result = await connection.query(query, params);
+      return result[0] ? result[0].total : 0;
+    } finally {
+      connection.release();
+    }
+  }
+
+  /**
+   * Método para ejecutar consultas personalizadas
+   * @param {string} query - Consulta personalizada
+   * @param {Array} params - Parámetros de la consulta
+   * @returns {Promise<any>} - Promesa con el resultado
+   */
+  async query(query, params = []) {
+    const connection = await this.pool.getConnection();
+    try {
+      return await connection.query(query, params);
+    } finally {
+      connection.release();
+    }
+  }
+
+  /**
+   * Método para inicializar el adaptador
+   * @returns {Promise<void>}
+   */
+  async initialize() {
+    try {
+      // Probar la conexión
+      const connection = await this.pool.getConnection();
+      connection.release();
+      this.logger.info('Conexión a MariaDB establecida correctamente');
+    } catch (error) {
+      this.logger.error('Error al inicializar la conexión a MariaDB:', error.message);
+      throw error;
+    }
+  }
+
+  /**
+   * Método para cerrar la conexión
+   * @returns {Promise<void>}
+   */
+  async close() {
+    try {
+      await this.pool.end();
+      this.logger.info('Conexión a MariaDB cerrada correctamente');
+    } catch (error) {
+      this.logger.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;
+    }
+  }
+
+  /**
+   * Método para migrar una tabla
+   * @param {string} tableName - Nombre de la tabla a migrar
+   * @returns {Promise<void>}
+   */
+  async migrate(tableName) {
+    // En una implementación completa, aquí se ejecutarían scripts de migración
+    // Por ahora, simplemente verificamos si la tabla existe
+    try {
+      await this.query(`SELECT 1 FROM ${tableName} LIMIT 1`);
+      this.logger.info(`Tabla ${tableName} ya existe`);
+    } catch (error) {
+      this.logger.warn(`Tabla ${tableName} no existe o no se puede acceder:`, error.message);
+      // Aquí se podría crear la tabla si no existe
+    }
+  }
+
+  /**
+   * Serializa el adaptador a JSON
+   * @returns {Object} - Representación JSON del adaptador
+   */
+  toJSON() {
+    const baseJson = super.toJSON();
+    return {
+      ...baseJson,
+      host: this.dbConfig.host,
+      database: this.dbConfig.database,
+      connected: this.isConnected()
+    };
+  }
+}
+
+module.exports = MariaDBAdapter;

package/lib/mvc/MemoryAdapter.js

@@ -0,0 +1,269 @@
+/**
+ * Adaptador de almacenamiento en memoria para modelos en el framework JERK
+ * Implementación del componente MVC MemoryAdapter.js
+ * Proporciona almacenamiento en memoria para modelos
+ */
+
+const GenericAdapter = require('./GenericAdapter');
+
+class MemoryAdapter extends GenericAdapter {
+  /**
+   * Constructor del adaptador en memoria
+   * @param {Object} options - Opciones de configuración
+   */
+  constructor(options = {}) {
+    super({ ...options, type: 'memory' });
+    
+    // Almacenamiento en memoria
+    this.storage = new Map();
+    this.autoIncrementIds = new Map();
+  }
+
+  /**
+   * Método para crear un registro
+   * @param {string} tableName - Nombre de la tabla
+   * @param {Object} data - Datos a crear
+   * @returns {Promise<Object>} - Promesa con el resultado
+   */
+  async create(tableName, data) {
+    // Inicializar la tabla si no existe
+    if (!this.storage.has(tableName)) {
+      this.storage.set(tableName, []);
+      this.autoIncrementIds.set(tableName, 1);
+    }
+
+    const table = this.storage.get(tableName);
+    const newId = this.autoIncrementIds.get(tableName);
+    
+    // Agregar ID al registro
+    const record = { id: newId, ...data, createdAt: new Date(), updatedAt: new Date() };
+    
+    // Actualizar ID autoincrementable
+    this.autoIncrementIds.set(tableName, newId + 1);
+    
+    // Agregar registro a la tabla
+    table.push(record);
+    
+    return { ...record };
+  }
+
+  /**
+   * 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>} - Promesa con los resultados
+   */
+  async find(tableName, conditions, options = {}) {
+    if (!this.storage.has(tableName)) {
+      return [];
+    }
+
+    let records = [...this.storage.get(tableName)];
+    
+    // Filtrar por condiciones
+    records = this.filterRecords(records, conditions);
+    
+    // Aplicar opciones
+    if (options.orderBy) {
+      records = this.sortRecords(records, options.orderBy);
+    }
+    
+    if (options.limit) {
+      const offset = options.offset || 0;
+      records = records.slice(offset, offset + options.limit);
+    }
+    
+    return records;
+  }
+
+  /**
+   * 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>} - Promesa con el resultado o null
+   */
+  async findOne(tableName, conditions, options = {}) {
+    const records = await this.find(tableName, conditions, { ...options, limit: 1 });
+    return records.length > 0 ? records[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>} - Promesa con el número de registros afectados
+   */
+  async update(tableName, conditions, data) {
+    if (!this.storage.has(tableName)) {
+      return 0;
+    }
+
+    const table = this.storage.get(tableName);
+    let updatedCount = 0;
+    
+    // Actualizar la marca de tiempo
+    const now = new Date();
+    data.updatedAt = now;
+    
+    for (let i = 0; i < table.length; i++) {
+      if (this.matchesConditions(table[i], conditions)) {
+        // Actualizar solo las propiedades proporcionadas
+        table[i] = { ...table[i], ...data };
+        updatedCount++;
+      }
+    }
+    
+    return updatedCount;
+  }
+
+  /**
+   * Método para eliminar registros
+   * @param {string} tableName - Nombre de la tabla
+   * @param {Object} conditions - Condiciones para seleccionar registros
+   * @returns {Promise<number>} - Promesa con el número de registros eliminados
+   */
+  async delete(tableName, conditions) {
+    if (!this.storage.has(tableName)) {
+      return 0;
+    }
+
+    const table = this.storage.get(tableName);
+    const initialLength = table.length;
+    
+    // Filtrar los registros que no coinciden con las condiciones
+    const filteredTable = table.filter(record => !this.matchesConditions(record, conditions));
+    
+    // Actualizar la tabla
+    this.storage.set(tableName, filteredTable);
+    
+    return initialLength - filteredTable.length;
+  }
+
+  /**
+   * Método para contar registros
+   * @param {string} tableName - Nombre de la tabla
+   * @param {Object} conditions - Condiciones de conteo
+   * @returns {Promise<number>} - Promesa con el número de registros
+   */
+  async count(tableName, conditions) {
+    if (!this.storage.has(tableName)) {
+      return 0;
+    }
+
+    const records = this.storage.get(tableName);
+    const filteredRecords = this.filterRecords(records, conditions);
+    return filteredRecords.length;
+  }
+
+  /**
+   * Método para ejecutar consultas personalizadas
+   * @param {string} query - Consulta personalizada (en este caso, una función)
+   * @param {Array} params - Parámetros de la consulta
+   * @returns {Promise<any>} - Promesa con el resultado
+   */
+  async query(query, params = []) {
+    // En el adaptador de memoria, tratamos la 'consulta' como una función
+    if (typeof query === 'function') {
+      return query(this.storage, ...params);
+    }
+    
+    throw new Error('En el adaptador de memoria, la consulta debe ser una función');
+  }
+
+  /**
+   * Método para filtrar registros según condiciones
+   * @param {Array} records - Array de registros
+   * @param {Object} conditions - Condiciones de filtrado
+   * @returns {Array} - Registros filtrados
+   */
+  filterRecords(records, conditions) {
+    if (!conditions || Object.keys(conditions).length === 0) {
+      return records;
+    }
+    
+    return records.filter(record => this.matchesConditions(record, conditions));
+  }
+
+  /**
+   * Método para verificar si un registro coincide con las condiciones
+   * @param {Object} record - Registro a verificar
+   * @param {Object} conditions - Condiciones a verificar
+   * @returns {boolean} - Verdadero si coincide
+   */
+  matchesConditions(record, conditions) {
+    for (const [key, value] of Object.entries(conditions)) {
+      if (record[key] !== value) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  /**
+   * Método para ordenar registros
+   * @param {Array} records - Array de registros
+   * @param {string} orderBy - Criterio de ordenamiento (ej: 'field ASC' o 'field DESC')
+   * @returns {Array} - Registros ordenados
+   */
+  sortRecords(records, orderBy) {
+    if (!orderBy) return records;
+    
+    const [field, direction] = orderBy.split(' ');
+    const isAscending = (direction || 'ASC').toUpperCase() === 'ASC';
+    
+    return records.sort((a, b) => {
+      const valueA = a[field];
+      const valueB = b[field];
+      
+      if (valueA < valueB) {
+        return isAscending ? -1 : 1;
+      } else if (valueA > valueB) {
+        return isAscending ? 1 : -1;
+      } else {
+        return 0;
+      }
+    });
+  }
+
+  /**
+   * Método para limpiar el almacenamiento
+   */
+  clear() {
+    this.storage.clear();
+    this.autoIncrementIds.clear();
+  }
+
+  /**
+   * Método para migrar una tabla
+   * @param {string} tableName - Nombre de la tabla a migrar
+   * @returns {Promise<void>}
+   */
+  async migrate(tableName) {
+    // En el adaptador de memoria, la migración simplemente inicializa la tabla
+    if (!this.storage.has(tableName)) {
+      this.storage.set(tableName, []);
+      this.autoIncrementIds.set(tableName, 1);
+    }
+  }
+
+  /**
+   * Serializa el adaptador a JSON
+   * @returns {Object} - Representación JSON del adaptador
+   */
+  toJSON() {
+    const baseJson = super.toJSON();
+    return {
+      ...baseJson,
+      tables: Array.from(this.storage.keys()),
+      recordCounts: Array.from(this.storage.entries()).reduce((acc, [tableName, records]) => {
+        acc[tableName] = records.length;
+        return acc;
+      }, {})
+    };
+  }
+}
+
+module.exports = MemoryAdapter;