jerkjs 2.1.6 → 2.2.0

package/lib/mvc/ModelControllerExample.js

@@ -0,0 +1,285 @@
+/**
+ * Controlador de ejemplo que demuestra la interacción con modelos en el framework JERK
+ * Implementación del componente MVC ModelControllerExample.js
+ * Muestra cómo los controladores pueden interactuar con modelos
+ */
+
+const ControllerBase = require('./controllerBase');
+
+// Importar componentes dinámicamente para evitar dependencias circulares
+let _ModelManager, _UserModel, _MemoryAdapter;
+
+const loadComponents = () => {
+  if (!_ModelManager || !_UserModel || !_MemoryAdapter) {
+    const components = require('../../index.js');
+    _ModelManager = components.ModelManager;
+    _UserModel = components.UserModel;
+    _MemoryAdapter = components.MemoryAdapter;
+  }
+  return { _ModelManager, _UserModel, _MemoryAdapter };
+};
+
+class ModelControllerExample extends ControllerBase {
+  constructor() {
+    super();
+
+    // Cargar componentes dinámicamente
+    const { _ModelManager, _MemoryAdapter } = loadComponents();
+
+    // Crear instancia del gestor de modelos
+    this.modelManager = new _ModelManager();
+
+    // Crear e registrar un adaptador de memoria
+    const memoryAdapter = new _MemoryAdapter();
+    this.modelManager.registerAdapter('memory', memoryAdapter);
+
+    // Crear e registrar el modelo de usuario
+    this.userModel = this.modelManager.createModel('User', {
+      adapterName: 'memory',
+      modelOptions: { tableName: 'users' }
+    });
+
+    // Asociar el modelo con este controlador para comunicación bidireccional
+    this.modelManager.associateModelWithController('User', this);
+  }
+
+  /**
+   * Método para obtener todos los usuarios
+   * @param {Object} req - Objeto de solicitud
+   * @param {Object} res - Objeto de respuesta
+   */
+  async getAllUsers(req, res) {
+    try {
+      const users = await this.userModel.find({});
+      
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ 
+        success: true, 
+        data: users,
+        count: users.length 
+      }));
+    } catch (error) {
+      console.error('Error obteniendo usuarios:', error);
+      res.writeHead(500, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ 
+        success: false, 
+        error: error.message 
+      }));
+    }
+  }
+
+  /**
+   * Método para obtener un usuario por ID
+   * @param {Object} req - Objeto de solicitud
+   * @param {Object} res - Objeto de respuesta
+   */
+  async getUserById(req, res) {
+    try {
+      const userId = req.params.id;
+      
+      if (!userId) {
+        res.writeHead(400, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ 
+          success: false, 
+          error: 'ID de usuario es requerido' 
+        }));
+        return;
+      }
+      
+      const user = await this.userModel.findOne({ id: parseInt(userId) });
+      
+      if (!user) {
+        res.writeHead(404, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ 
+          success: false, 
+          error: 'Usuario no encontrado' 
+        }));
+        return;
+      }
+      
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ 
+        success: true, 
+        data: user 
+      }));
+    } catch (error) {
+      console.error('Error obteniendo usuario por ID:', error);
+      res.writeHead(500, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ 
+        success: false, 
+        error: error.message 
+      }));
+    }
+  }
+
+  /**
+   * Método para crear un nuevo usuario
+   * @param {Object} req - Objeto de solicitud
+   * @param {Object} res - Objeto de respuesta
+   */
+  async createUser(req, res) {
+    try {
+      const userData = req.body;
+      
+      // Validar que se proporcionen los datos necesarios
+      if (!userData.username || !userData.email || !userData.password) {
+        res.writeHead(400, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ 
+          success: false, 
+          error: 'Username, email y password son requeridos' 
+        }));
+        return;
+      }
+      
+      // Crear el usuario usando el modelo
+      const newUser = await this.userModel.createUser(userData);
+      
+      res.writeHead(201, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ 
+        success: true, 
+        data: newUser 
+      }));
+    } catch (error) {
+      console.error('Error creando usuario:', error);
+      res.writeHead(500, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ 
+        success: false, 
+        error: error.message 
+      }));
+    }
+  }
+
+  /**
+   * Método para actualizar un usuario
+   * @param {Object} req - Objeto de solicitud
+   * @param {Object} res - Objeto de respuesta
+   */
+  async updateUser(req, res) {
+    try {
+      const userId = req.params.id;
+      const userData = req.body;
+      
+      if (!userId) {
+        res.writeHead(400, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ 
+          success: false, 
+          error: 'ID de usuario es requerido' 
+        }));
+        return;
+      }
+      
+      // Actualizar el usuario usando el modelo
+      const affectedRows = await this.userModel.updateUser({ id: parseInt(userId) }, userData);
+      
+      if (affectedRows === 0) {
+        res.writeHead(404, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ 
+          success: false, 
+          error: 'Usuario no encontrado' 
+        }));
+        return;
+      }
+      
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ 
+        success: true, 
+        message: 'Usuario actualizado exitosamente',
+        affectedRows
+      }));
+    } catch (error) {
+      console.error('Error actualizando usuario:', error);
+      res.writeHead(500, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ 
+        success: false, 
+        error: error.message 
+      }));
+    }
+  }
+
+  /**
+   * Método para eliminar un usuario
+   * @param {Object} req - Objeto de solicitud
+   * @param {Object} res - Objeto de respuesta
+   */
+  async deleteUser(req, res) {
+    try {
+      const userId = req.params.id;
+      
+      if (!userId) {
+        res.writeHead(400, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ 
+          success: false, 
+          error: 'ID de usuario es requerido' 
+        }));
+        return;
+      }
+      
+      // Eliminar el usuario usando el modelo
+      const deletedRows = await this.userModel.delete({ id: parseInt(userId) });
+      
+      if (deletedRows === 0) {
+        res.writeHead(404, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ 
+          success: false, 
+          error: 'Usuario no encontrado' 
+        }));
+        return;
+      }
+      
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ 
+        success: true, 
+        message: 'Usuario eliminado exitosamente',
+        deletedRows
+      }));
+    } catch (error) {
+      console.error('Error eliminando usuario:', error);
+      res.writeHead(500, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ 
+        success: false, 
+        error: error.message 
+      }));
+    }
+  }
+
+  /**
+   * Método para obtener usuarios con paginación
+   * @param {Object} req - Objeto de solicitud
+   * @param {Object} res - Objeto de respuesta
+   */
+  async getUsersPaginated(req, res) {
+    try {
+      // Obtener parámetros de paginación de la consulta
+      const page = parseInt(req.query.page) || 1;
+      const limit = parseInt(req.query.limit) || 10;
+      
+      // Validar parámetros
+      if (page < 1 || limit < 1 || limit > 100) {
+        res.writeHead(400, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ 
+          success: false, 
+          error: 'Parámetros de paginación inválidos' 
+        }));
+        return;
+      }
+      
+      // Obtener usuarios con paginación usando el modelo
+      const result = await this.userModel.getUsersPaginated({ page, limit });
+      
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ 
+        success: true, 
+        ...result
+      }));
+    } catch (error) {
+      console.error('Error obteniendo usuarios paginados:', error);
+      res.writeHead(500, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ 
+        success: false, 
+        error: error.message 
+      }));
+    }
+  }
+}
+
+module.exports = ModelControllerExample;

package/lib/mvc/controllerBase.js

@@ -202,6 +202,66 @@ class ControllerBase {
   clearViewData() {
     this.viewData = {};
   }
+
+  /**
+   * Carga un modelo para su uso en el controlador
+   * @param {string} modelName - Nombre del modelo a cargar
+   * @param {Object} options - Opciones para la creación del modelo
+   * @returns {ModelBase} - Instancia del modelo cargado
+   */
+  loadModel(modelName, options = {}) {
+    try {
+      // Construir la ruta del modelo
+      // Buscar en diferentes ubicaciones posibles
+      let ModelClass;
+
+      // Primero intentar cargar desde la carpeta models del proyecto
+      try {
+        ModelClass = require(`../../../models/${modelName}`);
+      } catch (e1) {
+        try {
+          // Intentar cargar desde la carpeta models relativa al controlador
+          ModelClass = require(`../models/${modelName}`);
+        } catch (e2) {
+          try {
+            // Intentar cargar desde la carpeta models en la raíz del proyecto
+            ModelClass = require(`../../models/${modelName}`);
+          } catch (e3) {
+            // Si no se encuentra en ninguno de los lugares comunes, lanzar error
+            throw new Error(`Modelo '${modelName}' no encontrado en ubicaciones estándar`);
+          }
+        }
+      }
+
+      // Crear instancia del modelo con las opciones proporcionadas
+      const modelInstance = new ModelClass(options);
+
+      // Guardar referencia del modelo en el controlador
+      if (!this.models) {
+        this.models = {};
+      }
+
+      this.models[modelName] = modelInstance;
+
+      return modelInstance;
+    } catch (error) {
+      console.error(`Error cargando modelo '${modelName}':`, error.message);
+      throw error;
+    }
+  }
+
+  /**
+   * Obtiene un modelo previamente cargado
+   * @param {string} modelName - Nombre del modelo a obtener
+   * @returns {ModelBase|null} - Instancia del modelo o null si no está cargado
+   */
+  getModel(modelName) {
+    if (!this.models) {
+      this.models = {};
+    }
+
+    return this.models[modelName] || null;
+  }
 }
 
 module.exports = ControllerBase;