jerkjs 2.0.0

package/lib/utils/configParser.js

@@ -0,0 +1,223 @@
+/**
+ * Parser de configuración para el framework API SDK
+ * Implementación del componente utils/configParser.js
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+class ConfigParser {
+  /**
+   * Constructor del parser de configuración
+   */
+  constructor() {
+    this.config = {};
+  }
+
+  /**
+   * Método para cargar configuración desde un archivo JSON
+   * @param {string} filePath - Ruta al archivo de configuración
+   * @returns {Object} - Configuración cargada
+   */
+  loadFromFile(filePath) {
+    try {
+      if (!fs.existsSync(filePath)) {
+        throw new Error(`Archivo de configuración no encontrado: ${filePath}`);
+      }
+
+      const configData = fs.readFileSync(filePath, 'utf8');
+      const parsedConfig = JSON.parse(configData);
+      
+      this.config = { ...this.config, ...parsedConfig };
+      return this.config;
+    } catch (error) {
+      throw new Error(`Error cargando configuración desde ${filePath}: ${error.message}`);
+    }
+  }
+
+  /**
+   * Método para cargar configuración desde variables de entorno
+   * @param {Object} env - Objeto con variables de entorno (por defecto process.env)
+   * @param {Object} mapping - Objeto que mapea variables de entorno a claves de configuración
+   * @returns {Object} - Configuración actualizada
+   */
+  loadFromEnv(env = process.env, mapping = {}) {
+    const envConfig = {};
+
+    // Si se proporciona un mapeo, usarlo para leer variables de entorno
+    if (Object.keys(mapping).length > 0) {
+      for (const [configKey, envVar] of Object.entries(mapping)) {
+        if (env[envVar] !== undefined) {
+          envConfig[configKey] = this.parseEnvValue(env[envVar]);
+        }
+      }
+    } else {
+      // Si no hay mapeo, buscar variables con prefijo API_
+      for (const [key, value] of Object.entries(env)) {
+        if (key.startsWith('API_')) {
+          const configKey = this.snakeToCamel(key.substring(4).toLowerCase()); // Remover API_ y convertir
+          envConfig[configKey] = this.parseEnvValue(value);
+        }
+      }
+    }
+
+    this.config = { ...this.config, ...envConfig };
+    return this.config;
+  }
+
+  /**
+   * Método para parsear valores de variables de entorno
+   * @param {string} value - Valor de la variable de entorno
+   * @returns {*} - Valor parseado (string, number, boolean, etc.)
+   */
+  parseEnvValue(value) {
+    // Intentar parsear como booleano
+    if (value.toLowerCase() === 'true') return true;
+    if (value.toLowerCase() === 'false') return false;
+    
+    // Intentar parsear como número
+    if (!isNaN(value) && value.trim() !== '') {
+      const numValue = Number(value);
+      if (!isNaN(numValue)) return numValue;
+    }
+    
+    // Si contiene comas, podría ser un array
+    if (value.includes(',')) {
+      return value.split(',').map(item => this.parseEnvValue(item.trim()));
+    }
+    
+    // Por defecto, retornar como string
+    return value;
+  }
+
+  /**
+   * Método para convertir snake_case a camelCase
+   * @param {string} str - Cadena en formato snake_case
+   * @returns {string} - Cadena en formato camelCase
+   */
+  snakeToCamel(str) {
+    return str.replace(/_([a-z])/g, (match, letter) => letter.toUpperCase());
+  }
+
+  /**
+   * Método para cargar configuración por defecto
+   * @param {Object} defaults - Configuración por defecto
+   * @returns {Object} - Configuración actualizada
+   */
+  loadDefaults(defaults) {
+    this.config = { ...defaults, ...this.config };
+    return this.config;
+  }
+
+  /**
+   * Método para obtener un valor de configuración
+   * @param {string} key - Clave de la configuración (puede usar notación de punto para objetos anidados)
+   * @param {*} defaultValue - Valor por defecto si no se encuentra la clave
+   * @returns {*} - Valor de la configuración
+   */
+  get(key, defaultValue = undefined) {
+    // Soportar notación de punto para acceder a propiedades anidadas
+    const keys = key.split('.');
+    let value = this.config;
+    
+    for (const k of keys) {
+      if (value === null || value === undefined || typeof value !== 'object') {
+        return defaultValue;
+      }
+      value = value[k];
+    }
+    
+    return value !== undefined ? value : defaultValue;
+  }
+
+  /**
+   * Método para establecer un valor de configuración
+   * @param {string} key - Clave de la configuración (puede usar notación de punto para objetos anidados)
+   * @param {*} value - Valor a establecer
+   */
+  set(key, value) {
+    // Soportar notación de punto para establecer propiedades anidadas
+    const keys = key.split('.');
+    let current = this.config;
+    
+    for (let i = 0; i < keys.length - 1; i++) {
+      const k = keys[i];
+      if (current[k] === undefined || current[k] === null) {
+        current[k] = {};
+      }
+      current = current[k];
+    }
+    
+    current[keys[keys.length - 1]] = value;
+  }
+
+  /**
+   * Método para obtener toda la configuración
+   * @returns {Object} - Objeto con toda la configuración
+   */
+  getAll() {
+    return { ...this.config };
+  }
+
+  /**
+   * Método para reiniciar la configuración
+   */
+  reset() {
+    this.config = {};
+  }
+
+  /**
+   * Método para validar la configuración contra un esquema
+   * @param {Object} schema - Esquema de validación
+   * @returns {Array} - Array de errores de validación
+   */
+  validate(schema) {
+    const errors = [];
+    
+    for (const [key, rules] of Object.entries(schema)) {
+      const value = this.get(key);
+      
+      if (rules.required && (value === undefined || value === null)) {
+        errors.push(`Campo requerido: ${key}`);
+        continue;
+      }
+      
+      if (value !== undefined && rules.type) {
+        const valueType = typeof value;
+        if (rules.type === 'array' && !Array.isArray(value)) {
+          errors.push(`Campo ${key} debe ser un array`);
+        } else if (rules.type !== 'array' && valueType !== rules.type) {
+          errors.push(`Campo ${key} debe ser de tipo ${rules.type}, pero es ${valueType}`);
+        }
+      }
+      
+      if (value !== undefined && rules.validator && typeof rules.validator === 'function') {
+        const isValid = rules.validator(value);
+        if (!isValid) {
+          errors.push(`Campo ${key} no pasó la validación personalizada`);
+        }
+      }
+    }
+    
+    return errors;
+  }
+
+  /**
+   * Método para guardar la configuración en un archivo
+   * @param {string} filePath - Ruta al archivo donde guardar la configuración
+   */
+  saveToFile(filePath) {
+    try {
+      const dir = path.dirname(filePath);
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+      
+      fs.writeFileSync(filePath, JSON.stringify(this.config, null, 2));
+    } catch (error) {
+      throw new Error(`Error guardando configuración en ${filePath}: ${error.message}`);
+    }
+  }
+}
+
+module.exports = ConfigParser;

package/lib/utils/logger.js

@@ -0,0 +1,145 @@
+/**
+ * Sistema de logging para el framework API SDK
+ * Implementación del componente utils/logger.js
+ */
+
+class Logger {
+  /**
+   * Constructor del logger
+   * @param {Object} options - Opciones de configuración
+   * @param {string} options.level - Nivel de log (debug, info, warn, error)
+   * @param {boolean} options.timestamp - Incluir timestamp en los logs
+   * @param {string} options.format - Formato de salida (simple, json)
+   */
+  constructor(options = {}) {
+    this.level = options.level || 'info';
+    this.timestamp = options.timestamp !== false; // Por defecto true
+    this.format = options.format || 'simple';
+    this.levels = {
+      debug: 0,
+      info: 1,
+      warn: 2,
+      error: 3
+    };
+  }
+
+  /**
+   * Método para registrar un mensaje de nivel debug
+   * @param {...any} args - Argumentos a loggear
+   */
+  debug(...args) {
+    if (this.levels[this.level] <= this.levels.debug) {
+      this._log('DEBUG', ...args);
+    }
+  }
+
+  /**
+   * Método para registrar un mensaje de nivel info
+   * @param {...any} args - Argumentos a loggear
+   */
+  info(...args) {
+    if (this.levels[this.level] <= this.levels.info) {
+      this._log('INFO', ...args);
+    }
+  }
+
+  /**
+   * Método para registrar un mensaje de nivel warn
+   * @param {...any} args - Argumentos a loggear
+   */
+  warn(...args) {
+    if (this.levels[this.level] <= this.levels.warn) {
+      this._log('WARN', ...args);
+    }
+  }
+
+  /**
+   * Método para registrar un mensaje de nivel error
+   * @param {...any} args - Argumentos a loggear
+   */
+  error(...args) {
+    if (this.levels[this.level] <= this.levels.error) {
+      this._log('ERROR', ...args);
+    }
+  }
+
+  /**
+   * Método privado para escribir el log
+   * @param {string} level - Nivel del log
+   * @param {...any} args - Argumentos a loggear
+   */
+  _log(level, ...args) {
+    const timestamp = this.timestamp ? new Date().toISOString() : '';
+    const message = args.map(arg => {
+      if (typeof arg === 'object') {
+        return JSON.stringify(arg, null, 2);
+      }
+      return String(arg);
+    }).join(' ');
+
+    if (this.format === 'json') {
+      const logEntry = {
+        timestamp,
+        level,
+        message
+      };
+      console.log(JSON.stringify(logEntry));
+    } else {
+      const prefix = timestamp ? `[${timestamp}] ${level}:` : `${level}:`;
+      console.log(prefix, message);
+    }
+  }
+
+  /**
+   * Método para cambiar el nivel de log
+   * @param {string} level - Nuevo nivel de log
+   */
+  setLevel(level) {
+    if (this.levels[level] !== undefined) {
+      this.level = level;
+    } else {
+      throw new Error(`Nivel de log inválido: ${level}. Niveles válidos: ${Object.keys(this.levels).join(', ')}`);
+    }
+  }
+
+  /**
+   * Método para crear un logger con contexto adicional
+   * @param {Object} context - Contexto adicional para los logs
+   * @returns {Logger} - Nueva instancia de Logger con contexto
+   */
+  withContext(context) {
+    const logger = new Logger({
+      level: this.level,
+      timestamp: this.timestamp,
+      format: this.format
+    });
+
+    // Sobrescribir el método _log para incluir contexto
+    logger._log = (level, ...args) => {
+      const timestamp = this.timestamp ? new Date().toISOString() : '';
+      const message = args.map(arg => {
+        if (typeof arg === 'object') {
+          return JSON.stringify(arg, null, 2);
+        }
+        return String(arg);
+      }).join(' ');
+
+      if (this.format === 'json') {
+        const logEntry = {
+          timestamp,
+          level,
+          context,
+          message
+        };
+        console.log(JSON.stringify(logEntry));
+      } else {
+        const prefix = timestamp ? `[${timestamp}] ${level}:` : `${level}:`;
+        console.log(prefix, `[${JSON.stringify(context)}]`, message);
+      }
+    };
+
+    return logger;
+  }
+}
+
+module.exports = { Logger };

package/lib/utils/mariadbTokenAdapter.js

@@ -0,0 +1,226 @@
+/**
+ * Adaptador de almacenamiento para MariaDB - Implementación Real
+ * Componente: lib/utils/mariadbTokenAdapter.js
+ */
+
+const mariadb = require('mariadb');
+
+class MariaDBTokenAdapter {
+  /**
+   * Constructor del adaptador
+   * @param {Object} config - Configuración de conexión a MariaDB
+   */
+  constructor(config) {
+    this.config = {
+      host: config.host || 'localhost',
+      port: config.port || 3306,
+      user: config.user || 'root',
+      password: config.password || '',
+      database: config.database || 'token_db',
+      connectionLimit: config.connectionLimit || 5
+    };
+    
+    this.pool = null;
+    this.tableName = config.tableName || 'tokens';
+  }
+
+  /**
+   * Inicializa la conexión y la tabla de tokens
+   */
+  async initialize() {
+    try {
+      // Crear pool de conexiones
+      this.pool = mariadb.createPool(this.config);
+      
+      // Crear tabla de tokens si no existe
+      await this.initializeTable();
+      
+      console.log('✅ Conexión a MariaDB establecida y tabla de tokens inicializada');
+    } catch (error) {
+      console.error('❌ Error inicializando MariaDB Token Adapter:', error.message);
+      throw error;
+    }
+  }
+
+  /**
+   * Inicializa la tabla de tokens en la base de datos
+   */
+  async initializeTable() {
+    const createTableQuery = `
+      CREATE TABLE IF NOT EXISTS ${this.tableName} (
+        id INT AUTO_INCREMENT PRIMARY KEY,
+        token VARCHAR(500) UNIQUE NOT NULL,
+        user_id INT NOT NULL,
+        token_type ENUM('access', 'refresh') DEFAULT 'access',
+        expires_at TIMESTAMP NOT NULL,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        revoked BOOLEAN DEFAULT FALSE,
+        INDEX idx_user_id (user_id),
+        INDEX idx_token (token),
+        INDEX idx_expires_at (expires_at)
+      )
+    `;
+    
+    let conn;
+    try {
+      conn = await this.pool.getConnection();
+      await conn.query(createTableQuery);
+      console.log(`✅ Tabla ${this.tableName} inicializada correctamente`);
+    } catch (error) {
+      console.error('❌ Error inicializando tabla de tokens:', error.message);
+      throw error;
+    } finally {
+      if (conn) conn.release();
+    }
+  }
+
+  /**
+   * Guarda un token en la base de datos
+   * @param {string} token - Token a guardar
+   * @param {Object} userData - Datos del usuario
+   * @param {string} tokenType - Tipo de token ('access' o 'refresh')
+   * @param {Date} expiresAt - Fecha de expiración
+   */
+  async saveToken(token, userData, tokenType = 'access', expiresAt) {
+    const insertQuery = `
+      INSERT INTO ${this.tableName} (token, user_id, token_type, expires_at) 
+      VALUES (?, ?, ?, ?)
+    `;
+    
+    let conn;
+    try {
+      conn = await this.pool.getConnection();
+      await conn.query(insertQuery, [
+        token,
+        userData.userId || userData.id,
+        tokenType,
+        expiresAt
+      ]);
+      
+      console.log(`✅ Token ${tokenType} guardado para usuario ${userData.userId || userData.id}`);
+    } catch (error) {
+      console.error('❌ Error guardando token:', error.message);
+      throw error;
+    } finally {
+      if (conn) conn.release();
+    }
+  }
+
+  /**
+   * Verifica si un token existe y es válido
+   * @param {string} token - Token a verificar
+   * @returns {Object|null} - Datos del token o null si no es válido
+   */
+  async validateToken(token) {
+    const selectQuery = `
+      SELECT * FROM ${this.tableName} 
+      WHERE token = ? AND revoked = FALSE AND expires_at > NOW()
+    `;
+    
+    let conn;
+    try {
+      conn = await this.pool.getConnection();
+      const rows = await conn.query(selectQuery, [token]);
+      return rows.length > 0 ? rows[0] : null;
+    } catch (error) {
+      console.error('❌ Error validando token:', error.message);
+      return null;
+    } finally {
+      if (conn) conn.release();
+    }
+  }
+
+  /**
+   * Revoca un token
+   * @param {string} token - Token a revocar
+   * @returns {boolean} - True si se revocó exitosamente
+   */
+  async revokeToken(token) {
+    const updateQuery = `
+      UPDATE ${this.tableName} 
+      SET revoked = TRUE 
+      WHERE token = ?
+    `;
+    
+    let conn;
+    try {
+      conn = await this.pool.getConnection();
+      const result = await conn.query(updateQuery, [token]);
+      const revoked = result.affectedRows > 0;
+      
+      if (revoked) {
+        console.log(`✅ Token revocado: ${token}`);
+      } else {
+        console.log(`⚠️  Token no encontrado o ya revocado: ${token}`);
+      }
+      
+      return revoked;
+    } catch (error) {
+      console.error('❌ Error revocando token:', error.message);
+      return false;
+    } finally {
+      if (conn) conn.release();
+    }
+  }
+
+  /**
+   * Obtiene tokens de un usuario
+   * @param {number} userId - ID del usuario
+   * @returns {Array} - Array de tokens del usuario
+   */
+  async getUserTokens(userId) {
+    const selectQuery = `
+      SELECT * FROM ${this.tableName} 
+      WHERE user_id = ? AND revoked = FALSE AND expires_at > NOW()
+    `;
+    
+    let conn;
+    try {
+      conn = await this.pool.getConnection();
+      const rows = await conn.query(selectQuery, [userId]);
+      return rows;
+    } catch (error) {
+      console.error('❌ Error obteniendo tokens de usuario:', error.message);
+      return [];
+    } finally {
+      if (conn) conn.release();
+    }
+  }
+
+  /**
+   * Limpia tokens expirados
+   */
+  async cleanupExpiredTokens() {
+    const deleteQuery = `
+      DELETE FROM ${this.tableName} 
+      WHERE expires_at <= NOW()
+    `;
+    
+    let conn;
+    try {
+      conn = await this.pool.getConnection();
+      const result = await conn.query(deleteQuery);
+      const deletedCount = result.affectedRows;
+      
+      console.log(`✅ Eliminados ${deletedCount} tokens expirados`);
+      return deletedCount;
+    } catch (error) {
+      console.error('❌ Error limpiando tokens expirados:', error.message);
+      return 0;
+    } finally {
+      if (conn) conn.release();
+    }
+  }
+
+  /**
+   * Cierra la conexión al pool
+   */
+  async close() {
+    if (this.pool) {
+      await this.pool.end();
+      console.log('🔒 Conexión a MariaDB cerrada');
+    }
+  }
+}
+
+module.exports = MariaDBTokenAdapter;