jerkjs 2.1.7 → 2.2.0

package/lib/mvc/modelBase.js

@@ -0,0 +1,383 @@
+/**
+ * Clase base para modelos en el framework JERK
+ * Implementación del componente MVC modelBase.js
+ * Permite la comunicación bidireccional con controladores y la interacción con componentes del framework
+ */
+
+// Importar hooks dinámicamente para evitar dependencias circulares
+let _hooks = null;
+const getHooks = () => {
+  if (!_hooks) {
+    _hooks = require('../../index.js').hooks;
+  }
+  return _hooks;
+};
+
+class ModelBase {
+  /**
+   * Constructor del modelo base
+   * @param {Object} options - Opciones de configuración del modelo
+   * @param {string} options.tableName - Nombre de la tabla en la base de datos
+   * @param {Object} options.adapter - Adaptador de base de datos a utilizar
+   * @param {Object} options.logger - Instancia de logger para auditoría
+   */
+  constructor(options = {}) {
+    this.tableName = options.tableName || this.constructor.name.toLowerCase();
+    this.adapter = options.adapter || null;
+    this.logger = options.logger || console;
+
+    // Almacenar referencias a controladores asociados
+    this.controllers = new Set();
+
+    // Inicializar hooks para el modelo
+    this.initializeHooks();
+  }
+
+  /**
+   * Inicializa los hooks específicos para el modelo
+   */
+  initializeHooks() {
+    // Disparar hook cuando se crea una instancia del modelo
+    const hooks = getHooks();
+    if (hooks) {
+      hooks.doAction('model_created', this.constructor.name, this);
+    }
+  }
+
+  /**
+   * Establece el adaptador de base de datos para el modelo
+   * @param {Object} adapter - Adaptador de base de datos
+   */
+  setAdapter(adapter) {
+    this.adapter = adapter;
+  }
+
+  /**
+   * Registra un controlador que puede interactuar con este modelo
+   * @param {Object} controller - Instancia del controlador
+   */
+  registerController(controller) {
+    this.controllers.add(controller);
+
+    // Disparar hook cuando se registra un controlador
+    const hooks = getHooks();
+    if (hooks) {
+      hooks.doAction('controller_registered_with_model', controller.constructor.name, this.constructor.name);
+    }
+  }
+
+  /**
+   * Elimina un controlador registrado
+   * @param {Object} controller - Instancia del controlador
+   */
+  unregisterController(controller) {
+    this.controllers.delete(controller);
+
+    // Disparar hook cuando se elimina un controlador
+    const hooks = getHooks();
+    if (hooks) {
+      hooks.doAction('controller_unregistered_from_model', controller.constructor.name, this.constructor.name);
+    }
+  }
+
+  /**
+   * Obtiene todos los controladores registrados
+   * @returns {Set} - Conjunto de controladores registrados
+   */
+  getControllers() {
+    return this.controllers;
+  }
+
+  /**
+   * Método para crear un nuevo registro
+   * @param {Object} data - Datos del nuevo registro
+   * @returns {Promise<Object>} - Promesa con el resultado de la operación
+   */
+  async create(data) {
+    if (!this.adapter) {
+      throw new Error(`No se ha configurado un adaptador para el modelo ${this.constructor.name}`);
+    }
+
+    // Disparar hook antes de crear
+    const hooks = getHooks();
+    if (hooks) {
+      data = hooks.applyFilters('model_before_create', data, this.constructor.name);
+    }
+
+    try {
+      const result = await this.adapter.create(this.tableName, data);
+
+      // Disparar hook después de crear
+      if (hooks) {
+        hooks.doAction('model_after_create', result, this.constructor.name);
+      }
+
+      return result;
+    } catch (error) {
+      this.logger.error(`Error creando registro en ${this.tableName}:`, error.message);
+
+      // Disparar hook en caso de error
+      if (hooks) {
+        hooks.doAction('model_create_error', error, this.constructor.name);
+      }
+
+      throw error;
+    }
+  }
+
+  /**
+   * Método para obtener registros
+   * @param {Object} conditions - Condiciones de búsqueda
+   * @param {Object} options - Opciones adicionales (orden, límites, etc.)
+   * @returns {Promise<Array>} - Promesa con los resultados
+   */
+  async find(conditions = {}, options = {}) {
+    if (!this.adapter) {
+      throw new Error(`No se ha configurado un adaptador para el modelo ${this.constructor.name}`);
+    }
+
+    // Disparar hook antes de buscar
+    const hooks = getHooks();
+    if (hooks) {
+      conditions = hooks.applyFilters('model_before_find', conditions, this.constructor.name);
+    }
+
+    try {
+      const results = await this.adapter.find(this.tableName, conditions, options);
+
+      // Disparar hook después de buscar
+      if (hooks) {
+        hooks.doAction('model_after_find', results, this.constructor.name);
+      }
+
+      return results;
+    } catch (error) {
+      this.logger.error(`Error buscando registros en ${this.tableName}:`, error.message);
+
+      // Disparar hook en caso de error
+      if (hooks) {
+        hooks.doAction('model_find_error', error, this.constructor.name);
+      }
+
+      throw error;
+    }
+  }
+
+  /**
+   * Método para obtener un solo registro
+   * @param {Object} conditions - Condiciones de búsqueda
+   * @param {Object} options - Opciones adicionales
+   * @returns {Promise<Object|null>} - Promesa con el resultado o null
+   */
+  async findOne(conditions = {}, options = {}) {
+    if (!this.adapter) {
+      throw new Error(`No se ha configurado un adaptador para el modelo ${this.constructor.name}`);
+    }
+
+    // Disparar hook antes de buscar uno
+    const hooks = getHooks();
+    if (hooks) {
+      conditions = hooks.applyFilters('model_before_find_one', conditions, this.constructor.name);
+    }
+
+    try {
+      const result = await this.adapter.findOne(this.tableName, conditions, options);
+
+      // Disparar hook después de buscar uno
+      if (hooks) {
+        hooks.doAction('model_after_find_one', result, this.constructor.name);
+      }
+
+      return result;
+    } catch (error) {
+      this.logger.error(`Error buscando un registro en ${this.tableName}:`, error.message);
+
+      // Disparar hook en caso de error
+      if (hooks) {
+        hooks.doAction('model_find_one_error', error, this.constructor.name);
+      }
+
+      throw error;
+    }
+  }
+
+  /**
+   * Método para actualizar registros
+   * @param {Object} conditions - Condiciones para seleccionar registros a actualizar
+   * @param {Object} data - Datos a actualizar
+   * @returns {Promise<number>} - Número de registros afectados
+   */
+  async update(conditions, data) {
+    if (!this.adapter) {
+      throw new Error(`No se ha configurado un adaptador para el modelo ${this.constructor.name}`);
+    }
+
+    // Disparar hook antes de actualizar
+    const hooks = getHooks();
+    if (hooks) {
+      const hookResult = hooks.applyFilters('model_before_update', { conditions, data }, this.constructor.name);
+      conditions = hookResult.conditions;
+      data = hookResult.data;
+    }
+
+    try {
+      const result = await this.adapter.update(this.tableName, conditions, data);
+
+      // Disparar hook después de actualizar
+      if (hooks) {
+        hooks.doAction('model_after_update', result, data, this.constructor.name);
+      }
+
+      return result;
+    } catch (error) {
+      this.logger.error(`Error actualizando registros en ${this.tableName}:`, error.message);
+
+      // Disparar hook en caso de error
+      if (hooks) {
+        hooks.doAction('model_update_error', error, this.constructor.name);
+      }
+
+      throw error;
+    }
+  }
+
+  /**
+   * Método para eliminar registros
+   * @param {Object} conditions - Condiciones para seleccionar registros a eliminar
+   * @returns {Promise<number>} - Número de registros eliminados
+   */
+  async delete(conditions) {
+    if (!this.adapter) {
+      throw new Error(`No se ha configurado un adaptador para el modelo ${this.constructor.name}`);
+    }
+
+    // Disparar hook antes de eliminar
+    const hooks = getHooks();
+    if (hooks) {
+      conditions = hooks.applyFilters('model_before_delete', conditions, this.constructor.name);
+    }
+
+    try {
+      const result = await this.adapter.delete(this.tableName, conditions);
+
+      // Disparar hook después de eliminar
+      if (hooks) {
+        hooks.doAction('model_after_delete', result, this.constructor.name);
+      }
+
+      return result;
+    } catch (error) {
+      this.logger.error(`Error eliminando registros en ${this.tableName}:`, error.message);
+
+      // Disparar hook en caso de error
+      if (hooks) {
+        hooks.doAction('model_delete_error', error, this.constructor.name);
+      }
+
+      throw error;
+    }
+  }
+
+  /**
+   * Método para contar registros
+   * @param {Object} conditions - Condiciones de conteo
+   * @returns {Promise<number>} - Número de registros
+   */
+  async count(conditions = {}) {
+    if (!this.adapter) {
+      throw new Error(`No se ha configurado un adaptador para el modelo ${this.constructor.name}`);
+    }
+
+    const hooks = getHooks();
+    try {
+      const result = await this.adapter.count(this.tableName, conditions);
+
+      // Disparar hook después de contar
+      if (hooks) {
+        hooks.doAction('model_count_result', result, this.constructor.name);
+      }
+
+      return result;
+    } catch (error) {
+      this.logger.error(`Error contando registros en ${this.tableName}:`, error.message);
+
+      // Disparar hook en caso de error
+      if (hooks) {
+        hooks.doAction('model_count_error', error, this.constructor.name);
+      }
+
+      throw error;
+    }
+  }
+
+  /**
+   * Método para ejecutar consultas personalizadas
+   * @param {string} query - Consulta personalizada
+   * @param {Array} params - Parámetros de la consulta
+   * @returns {Promise<any>} - Resultado de la consulta
+   */
+  async query(query, params = []) {
+    if (!this.adapter) {
+      throw new Error(`No se ha configurado un adaptador para el modelo ${this.constructor.name}`);
+    }
+
+    const hooks = getHooks();
+    try {
+      const result = await this.adapter.query(query, params);
+
+      // Disparar hook después de la consulta
+      if (hooks) {
+        hooks.doAction('model_custom_query_result', result, query, this.constructor.name);
+      }
+
+      return result;
+    } catch (error) {
+      this.logger.error(`Error ejecutando consulta personalizada en ${this.tableName}:`, error.message);
+
+      // Disparar hook en caso de error
+      if (hooks) {
+        hooks.doAction('model_custom_query_error', error, query, this.constructor.name);
+      }
+
+      throw error;
+    }
+  }
+
+  /**
+   * Método para validar datos antes de operaciones CRUD
+   * @param {string} operation - Operación a realizar (create, update, etc.)
+   * @param {Object} data - Datos a validar
+   * @returns {boolean} - Verdadero si los datos son válidos
+   */
+  validate(operation, data) {
+    // Disparar hook para validación
+    const hooks = getHooks();
+    if (hooks) {
+      const validationResult = hooks.applyFilters(
+        'model_validate',
+        { isValid: true, errors: [] },
+        operation,
+        data,
+        this.constructor.name
+      );
+
+      return validationResult;
+    }
+
+    return { isValid: true, errors: [] };
+  }
+
+  /**
+   * Método para serializar el modelo a JSON
+   * @returns {Object} - Representación JSON del modelo
+   */
+  toJSON() {
+    return {
+      tableName: this.tableName,
+      hasAdapter: !!this.adapter,
+      registeredControllersCount: this.controllers.size
+    };
+  }
+}
+
+module.exports = ModelBase;

package/lib/mvc/modelManager.js

@@ -0,0 +1,284 @@
+/**
+ * Gestor de modelos para el framework JERK
+ * Implementación del componente MVC modelManager.js
+ * Administra instancias de modelos y su interacción con componentes del framework
+ */
+
+const ModelBase = require('./modelBase');
+
+// Importar hooks dinámicamente para evitar dependencias circulares
+let _hooks = null;
+const getHooks = () => {
+  if (!_hooks) {
+    _hooks = require('../../index.js').hooks;
+  }
+  return _hooks;
+};
+
+class ModelManager {
+  /**
+   * Constructor del gestor de modelos
+   * @param {Object} options - Opciones de configuración
+   */
+  constructor(options = {}) {
+    this.models = new Map(); // Almacena instancias de modelos
+    this.adapters = new Map(); // Almacena adaptadores disponibles
+    this.logger = options.logger || console;
+
+    // Inicializar hooks para el gestor de modelos
+    this.initializeHooks();
+  }
+
+  /**
+   * Inicializa los hooks específicos para el gestor de modelos
+   */
+  initializeHooks() {
+    // Disparar hook cuando se crea una instancia del gestor de modelos
+    const hooks = getHooks();
+    if (hooks) {
+      hooks.doAction('model_manager_created', this);
+    }
+  }
+
+  /**
+   * Registra un adaptador de base de datos
+   * @param {string} name - Nombre del adaptador
+   * @param {Object} adapter - Instancia del adaptador
+   */
+  registerAdapter(name, adapter) {
+    this.adapters.set(name, adapter);
+
+    // Disparar hook cuando se registra un adaptador
+    const hooks = getHooks();
+    if (hooks) {
+      hooks.doAction('adapter_registered', name, adapter);
+    }
+  }
+
+  /**
+   * Obtiene un adaptador registrado
+   * @param {string} name - Nombre del adaptador
+   * @returns {Object|null} - Instancia del adaptador o null
+   */
+  getAdapter(name) {
+    return this.adapters.get(name) || null;
+  }
+
+  /**
+   * Registra un modelo en el gestor
+   * @param {string} name - Nombre del modelo
+   * @param {ModelBase} model - Instancia del modelo
+   */
+  registerModel(name, model) {
+    if (!(model instanceof ModelBase)) {
+      throw new Error('El modelo debe ser una instancia de ModelBase');
+    }
+
+    this.models.set(name, model);
+
+    // Disparar hook cuando se registra un modelo
+    const hooks = getHooks();
+    if (hooks) {
+      hooks.doAction('model_registered', name, model);
+    }
+  }
+
+  /**
+   * Obtiene un modelo registrado
+   * @param {string} name - Nombre del modelo
+   * @returns {ModelBase|null} - Instancia del modelo o null
+   */
+  getModel(name) {
+    return this.models.get(name) || null;
+  }
+
+  /**
+   * Crea una instancia de modelo con un adaptador específico
+   * @param {string} modelName - Nombre del modelo
+   * @param {Object} options - Opciones para la creación del modelo
+   * @param {string} options.adapterName - Nombre del adaptador a usar
+   * @param {Object} options.modelOptions - Opciones específicas del modelo
+   * @returns {ModelBase} - Instancia del modelo creado
+   */
+  createModel(modelName, options = {}) {
+    const { adapterName, modelOptions = {} } = options;
+    
+    // Obtener el adaptador si se especificó
+    let adapter = null;
+    if (adapterName) {
+      adapter = this.getAdapter(adapterName);
+      if (!adapter) {
+        throw new Error(`Adaptador '${adapterName}' no encontrado para el modelo '${modelName}'`);
+      }
+    }
+    
+    // Crear una clase modelo dinámicamente si no existe
+    if (!this.models.has(modelName)) {
+      // Creamos una clase modelo específica para este nombre
+      class DynamicModel extends ModelBase {
+        constructor(opts) {
+          super(opts);
+          this.modelName = modelName;
+        }
+      }
+      
+      // Instanciar el modelo con el adaptador
+      const modelInstance = new DynamicModel({
+        ...modelOptions,
+        adapter: adapter,
+        logger: this.logger
+      });
+      
+      // Registrar el modelo
+      this.registerModel(modelName, modelInstance);
+      
+      return modelInstance;
+    } else {
+      // Si ya existe, actualizar el adaptador si se proporcionó
+      const existingModel = this.getModel(modelName);
+      if (adapter) {
+        existingModel.setAdapter(adapter);
+      }
+      
+      return existingModel;
+    }
+  }
+
+  /**
+   * Asocia un modelo con un controlador para permitir comunicación bidireccional
+   * @param {string} modelName - Nombre del modelo
+   * @param {Object} controller - Instancia del controlador
+   */
+  associateModelWithController(modelName, controller) {
+    const model = this.getModel(modelName);
+    if (!model) {
+      throw new Error(`Modelo '${modelName}' no encontrado`);
+    }
+    
+    // Registrar el controlador en el modelo
+    model.registerController(controller);
+
+    // Disparar hook cuando se asocia un modelo con un controlador
+    const hooks = getHooks();
+    if (hooks) {
+      hooks.doAction('model_controller_associated', modelName, controller.constructor.name);
+    }
+  }
+
+  /**
+   * Obtiene todos los modelos registrados
+   * @returns {Map} - Mapa de modelos registrados
+   */
+  getModels() {
+    return this.models;
+  }
+
+  /**
+   * Obtiene todos los adaptadores registrados
+   * @returns {Map} - Mapa de adaptadores registrados
+   */
+  getAdapters() {
+    return this.adapters;
+  }
+
+  /**
+   * Inicializa todos los modelos con un adaptador por defecto
+   * @param {string} adapterName - Nombre del adaptador por defecto
+   */
+  async initializeAllModels(adapterName) {
+    const adapter = this.getAdapter(adapterName);
+    if (!adapter) {
+      throw new Error(`Adaptador '${adapterName}' no encontrado`);
+    }
+    
+    // Configurar el adaptador para todos los modelos que no lo tengan
+    for (const [modelName, model] of this.models) {
+      if (!model.adapter) {
+        model.setAdapter(adapter);
+
+        // Disparar hook cuando se inicializa un modelo con un adaptador
+        const hooks = getHooks();
+        if (hooks) {
+          hooks.doAction('model_initialized_with_adapter', modelName, adapterName);
+        }
+      }
+    }
+  }
+
+  /**
+   * Método para migrar todas las tablas de los modelos
+   * @param {string} adapterName - Nombre del adaptador a usar para la migración
+   */
+  async migrateAll(adapterName) {
+    const adapter = this.getAdapter(adapterName);
+    if (!adapter) {
+      throw new Error(`Adaptador '${adapterName}' no encontrado`);
+    }
+    
+    // Verificar si el adaptador tiene método de migración
+    if (typeof adapter.migrate !== 'function') {
+      throw new Error(`El adaptador '${adapterName}' no soporta migraciones`);
+    }
+    
+    // Realizar migración para cada modelo
+    for (const [modelName, model] of this.models) {
+      try {
+        await adapter.migrate(model.tableName);
+
+        // Disparar hook cuando se migra una tabla
+        const hooks = getHooks();
+        if (hooks) {
+          hooks.doAction('model_table_migrated', modelName, model.tableName);
+        }
+      } catch (error) {
+        this.logger.error(`Error migrando tabla para el modelo '${modelName}':`, error.message);
+
+        // Disparar hook en caso de error de migración
+        const hooks = getHooks();
+        if (hooks) {
+          hooks.doAction('model_migration_error', modelName, error);
+        }
+
+        throw error;
+      }
+    }
+  }
+
+  /**
+   * Método para limpiar (eliminar) todos los modelos del gestor
+   */
+  clear() {
+    this.models.clear();
+
+    // Disparar hook cuando se limpia el gestor de modelos
+    const hooks = getHooks();
+    if (hooks) {
+      hooks.doAction('model_manager_cleared', this);
+    }
+  }
+
+  /**
+   * Serializa el estado del gestor de modelos a JSON
+   * @returns {Object} - Representación JSON del gestor de modelos
+   */
+  toJSON() {
+    const modelsInfo = {};
+    for (const [name, model] of this.models) {
+      modelsInfo[name] = model.toJSON();
+    }
+    
+    const adaptersInfo = {};
+    for (const [name, adapter] of this.adapters) {
+      adaptersInfo[name] = { registered: true };
+    }
+    
+    return {
+      registeredModels: Object.keys(modelsInfo),
+      registeredAdapters: Object.keys(adaptersInfo),
+      modelsInfo,
+      adaptersInfo
+    };
+  }
+}
+
+module.exports = ModelManager;