jerkjs 2.5.2 → 2.5.6

package/doc-2.5/manual-mvc-completo.md

@@ -0,0 +1,934 @@
+# Manual Completo: Desarrollo de Aplicaciones MVC en JERK Framework v2.5.3
+
+## Tabla de Contenidos
+1. [Desarrollo MVC](#desarrollo-mvc)
+   - [Crear Controlador](#crear-controlador)
+   - [Crear Modelo](#crear-modelo)
+   - [Crear Vista](#crear-vista)
+   - [Registrar Rutas](#registrar-rutas)
+2. [Sistema de Hooks y Filters](#sistema-de-hooks-y-filters)
+   - [Registrar Hooks](#registrar-hooks)
+   - [Registrar Filters](#registrar-filters)
+3. [Creación de Extensiones](#creación-de-extensiones)
+
+---
+
+## Desarrollo MVC
+
+### Crear Controlador
+
+Para crear un controlador en JERK Framework, debes extender la clase `ControllerBase`:
+
+```javascript
+// controllers/EjemploController.js
+const { ControllerBase } = require('jerkjs');
+
+class EjemploController extends ControllerBase {
+  constructor() {
+    super();
+  }
+
+  // Método para mostrar la lista de elementos
+  async index(req, res) {
+    try {
+      // Cargar el modelo con el adaptador desde la solicitud
+      const adapter = req.modelManager?.getAdapter('memory') || null;
+      const modelo = await this.loadModel('EjemploModel', { adapter });
+      
+      // Obtener datos del modelo
+      const elementos = await modelo.getAll();
+      
+      // Renderizar vista con datos
+      res.render('ejemplo/index', {
+        title: 'Lista de Elementos',
+        elementos: elementos
+      });
+    } catch (error) {
+      console.error('Error en el controlador:', error);
+      res.writeHead(500, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: 'Error interno del servidor' }));
+    }
+  }
+
+  // Método para mostrar un elemento específico
+  async show(req, res) {
+    try {
+      const adapter = req.modelManager?.getAdapter('memory') || null;
+      const modelo = await this.loadModel('EjemploModel', { adapter });
+      
+      const id = req.params.id;
+      const elemento = await modelo.getById(id);
+      
+      if (!elemento) {
+        res.writeHead(404, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'Elemento no encontrado' }));
+        return;
+      }
+      
+      res.render('ejemplo/show', {
+        title: `Elemento #${id}`,
+        elemento: elemento
+      });
+    } catch (error) {
+      console.error('Error en el controlador:', error);
+      res.writeHead(500, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: 'Error interno del servidor' }));
+    }
+  }
+
+  // Método para crear un nuevo elemento
+  async create(req, res) {
+    try {
+      const adapter = req.modelManager?.getAdapter('memory') || null;
+      const modelo = await this.loadModel('EjemploModel', { adapter });
+      
+      const datos = req.body;
+      const id = await modelo.create(datos);
+      
+      res.writeHead(201, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ 
+        success: true, 
+        id: id,
+        message: 'Elemento creado exitosamente'
+      }));
+    } catch (error) {
+      console.error('Error en el controlador:', error);
+      res.writeHead(500, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: 'Error interno del servidor' }));
+    }
+  }
+}
+
+// Crear instancia y preservar contexto
+const ejemploController = new EjemploController();
+ejemploController.index = ejemploController.index.bind(ejemploController);
+ejemploController.show = ejemploController.show.bind(ejemploController);
+ejemploController.create = ejemploController.create.bind(ejemploController);
+
+module.exports = ejemploController;
+```
+
+#### Características del Controlador:
+- Extiende `ControllerBase` para acceder a funcionalidades MVC
+- Preserva el contexto `this` usando `bind()`
+- Accede al modelManager a través de `req.modelManager`
+- Utiliza `loadModel()` para cargar modelos con adaptadores
+- Usa `res.render()` para mostrar vistas
+
+### Uso de loadModel
+
+El método `loadModel()` es fundamental para cargar modelos en los controladores. Su uso correcto es esencial para el funcionamiento del sistema MVC:
+
+```javascript
+// Cargar un modelo sin opciones adicionales
+const modelo = await this.loadModel('NombreDelModelo');
+
+// Cargar un modelo con un adaptador específico
+const adapter = req.modelManager?.getAdapter('memory') || null;
+const modelo = await this.loadModel('NombreDelModelo', { 
+  adapter: adapter 
+});
+
+// Cargar un modelo con opciones adicionales
+const modelo = await this.loadModel('NombreDelModelo', {
+  adapter: adapter,
+  tableName: 'nombre_tabla',
+  logger: console
+});
+
+// Cargar un modelo desde un directorio personalizado
+const modelo = await this.loadModel('NombreDelModelo', {
+  adapter: adapter,
+  modelDir: './mi-estructura-especial/models/usuarios'
+});
+```
+
+#### Características de loadModel:
+- **Búsqueda inteligente**: Busca el modelo en múltiples ubicaciones posibles (`./models/`, `../models/`, etc.)
+- **Reutilización de instancias**: Si ya existe una instancia del modelo en el controlador, la reutiliza
+- **Gestión de adaptadores**: Permite asignar un adaptador de base de datos al modelo
+- **Caché interno**: Mantiene una caché de instancias para mejorar el rendimiento
+
+#### Ejemplo completo de uso en un controlador:
+```javascript
+async index(req, res) {
+  try {
+    // Obtener el adaptador desde el modelManager en la solicitud
+    const adapter = req.modelManager?.getAdapter('memory') || null;
+    
+    // Cargar el modelo con el adaptador
+    const userModel = await this.loadModel('UserModel', {
+      adapter: adapter
+    });
+    
+    // Utilizar el modelo para obtener datos
+    const users = await userModel.getAll();
+    
+    // Renderizar la vista con los datos
+    res.render('users/index', {
+      title: 'Lista de Usuarios',
+      users: users
+    });
+  } catch (error) {
+    console.error('Error en el controlador:', error);
+    res.writeHead(500, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ error: 'Error interno del servidor' }));
+  }
+}
+```
+
+#### Convenciones de nomenclatura:
+- El nombre del modelo en `loadModel()` debe coincidir con el nombre del archivo del modelo
+- Si el archivo es `UserModel.js`, usar `'UserModel'` como parámetro
+- El sistema buscará en `./models/UserModel.js`, `../models/UserModel.js`, etc.
+
+#### Carga de modelos en subdirectorios o ubicaciones personalizadas:
+
+Cuando los modelos están en subdirectorios o ubicaciones no estándar, puedes usar las siguientes estrategias:
+
+1. **Importar directamente y pasar la clase al controlador**:
+```javascript
+// En el controlador
+const UserModel = require('../path/a/tu/modelo/UserModel');
+const modelo = new UserModel(adapter);
+// Usar el modelo directamente sin loadModel()
+```
+
+2. **Modificar el sistema de búsqueda de loadModel** (requiere extensión):
+```javascript
+// Puedes extender ControllerBase para personalizar la búsqueda
+class MiControllerBase extends ControllerBase {
+  async loadModel(modelName, options = {}) {
+    // Lógica personalizada de búsqueda
+    // Buscar en ubicaciones personalizadas
+    try {
+      // Intentar rutas personalizadas
+      const customPath = `./mis-modelos/especializados/${modelName}`;
+      const ModelClass = require(customPath);
+      return new ModelClass(options);
+    } catch (error) {
+      // Si falla, usar la lógica estándar
+      return super.loadModel(modelName, options);
+    }
+  }
+}
+```
+
+3. **Usar rutas absolutas o relativas específicas**:
+```javascript
+// En lugar de usar loadModel, importar directamente
+const { UserModel } = require('../../estructura-compleja/usuarios/UserModel');
+// Crear instancia manualmente
+const userModel = new UserModel({ adapter: req.modelManager?.getAdapter('memory') });
+```
+
+5. **Usar la nueva funcionalidad de directorio personalizado**:
+```javascript
+// Cargar un modelo desde un directorio personalizado
+const adapter = req.modelManager?.getAdapter('memory') || null;
+const modelo = await this.loadModel('MiModelo', {
+  adapter: adapter,
+  modelDir: './estructura-personalizada/modelos/usuarios'
+});
+
+// Esto buscará en: ./estructura-personalizada/modelos/usuarios/MiModelo
+// y en: ./estructura-personalizada/modelos/usuarios/MiModelo.js
+```
+
+6. **Estructura recomendada para proyectos complejos**:
+```
+mi-proyecto/
+├── controllers/
+│   └── usuarios/
+│       └── UsuarioController.js
+├── models/
+│   └── usuarios/
+│       └── UsuarioModel.js
+├── views/
+│   └── usuarios/
+│       └── index.html
+└── routes/
+    └── usuarios-routes.json
+```
+
+En este caso, el sistema de búsqueda de `loadModel` debería encontrar el modelo si está en `./models/usuarios/UsuarioModel.js` cuando se llama desde un controlador en `./controllers/usuarios/`.
+
+### Crear Modelo
+
+Para crear un modelo en JERK Framework, debes extender la clase `ModelBase`:
+
+```javascript
+// models/EjemploModel.js
+const { ModelBase } = require('jerkjs');
+
+class EjemploModel extends ModelBase {
+  constructor(options = {}) {
+    super(options);
+    this.tableName = 'ejemplos'; // Nombre de la tabla en la base de datos
+  }
+
+  // Método para obtener todos los registros
+  async getAll() {
+    return await this.find({}, { orderBy: 'id', orderDirection: 'ASC' });
+  }
+
+  // Método para obtener un registro por ID
+  async getById(id) {
+    return await this.findOne({ id: parseInt(id) });
+  }
+
+  // Método para crear un nuevo registro
+  async create(datos) {
+    return await super.create(datos);
+  }
+
+  // Método para actualizar un registro
+  async update(id, datos) {
+    return await super.update({ id: parseInt(id) }, datos);
+  }
+
+  // Método para eliminar un registro
+  async delete(id) {
+    return await super.delete({ id: parseInt(id) });
+  }
+
+  // Método personalizado para búsqueda
+  async findByField(fieldName, value) {
+    const conditions = {};
+    conditions[fieldName] = value;
+    return await this.find(conditions);
+  }
+}
+
+module.exports = EjemploModel;
+```
+
+#### Características del Modelo:
+- Extiende `ModelBase` para acceder a funcionalidades CRUD
+- Define el nombre de la tabla con `this.tableName`
+- Utiliza métodos heredados como `find()`, `findOne()`, `create()`, etc.
+- Puede incluir métodos personalizados para operaciones específicas
+- Se integra con adaptadores de base de datos
+
+### Crear Vista
+
+Las vistas en JERK Framework utilizan un sistema de plantillas con soporte para variables dinámicas:
+
+```html
+<!-- views/ejemplo/index.html -->
+<!DOCTYPE html>
+<html lang="es">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>{{title}}</title>
+    <style>
+        body { font-family: Arial, sans-serif; margin: 40px; }
+        .item { border: 1px solid #ccc; padding: 10px; margin: 10px 0; }
+        .btn { padding: 8px 16px; background-color: #007bff; color: white; text-decoration: none; border-radius: 4px; margin: 5px; display: inline-block; }
+    </style>
+</head>
+<body>
+    <h1>{{title}}</h1>
+    
+    <div class="actions">
+        <a href="/api/ejemplos/create" class="btn">Crear Nuevo</a>
+    </div>
+    
+    <div class="items-list">
+        {{#each elementos}}
+        <div class="item">
+            <h3>{{this.nombre}}</h3>
+            <p>ID: {{this.id}}</p>
+            <p>Descripción: {{this.descripcion}}</p>
+            <a href="/api/ejemplos/{{this.id}}" class="btn">Ver Detalles</a>
+        </div>
+        {{/each}}
+    </div>
+    
+    {{#unless elementos}}
+    <p>No hay elementos disponibles.</p>
+    {{/unless}}
+</body>
+</html>
+```
+
+#### Características de las Vistas:
+- Soporte para variables dinámicas con sintaxis `{{variable}}`
+- Soporte para estructuras condicionales y bucles con Handlebars
+- Integración con layouts para mantener consistencia visual
+- Pueden recibir datos desde los controladores
+
+### Registrar Rutas
+
+Existen tres formas de registrar rutas en JERK Framework:
+
+#### 1. Programáticamente
+
+```javascript
+// server.js
+const { APIServer } = require('jerkjs');
+
+const server = new APIServer({
+  port: 3000,
+  host: 'localhost'
+});
+
+// Importar controladores
+const ejemploController = require('./controllers/EjemploController');
+
+// Registrar rutas programáticamente
+server.addRoute('GET', '/api/ejemplos', ejemploController.index);
+server.addRoute('GET', '/api/ejemplos/:id', ejemploController.show);
+server.addRoute('POST', '/api/ejemplos', ejemploController.create);
+
+server.start();
+```
+
+#### 2. Usando routes.json
+
+```json
+// routes.json
+[
+  {
+    "path": "/api/ejemplos",
+    "method": "GET",
+    "controller": "./controllers/EjemploController.js",
+    "handler": "index",
+    "contentType": "text/html"
+  },
+  {
+    "path": "/api/ejemplos/:id",
+    "method": "GET",
+    "controller": "./controllers/EjemploController.js",
+    "handler": "show",
+    "contentType": "text/html"
+  },
+  {
+    "path": "/api/ejemplos",
+    "method": "POST",
+    "controller": "./controllers/EjemploController.js",
+    "handler": "create",
+    "contentType": "application/json"
+  },
+  {
+    "path": "/api/ejemplos/static",
+    "method": "GET",
+    "static": {
+      "dir": "./public",
+      "index": ["index.html"],
+      "cacheControl": "public, max-age=3600"
+    }
+  }
+]
+```
+
+```javascript
+// Cargar rutas desde archivo JSON
+const { APIServer, RouteLoader } = require('jerkjs');
+
+const server = new APIServer({ port: 3000 });
+const routeLoader = new RouteLoader();
+
+routeLoader.loadRoutes(server, './routes.json')
+  .then(() => server.start())
+  .catch(error => console.error('Error:', error.message));
+```
+
+#### 3. Usando Múltiples Ficheros de Ruta
+
+```javascript
+// Cargar rutas desde directorio
+const { APIServer, RouteDirectoryLoader } = require('jerkjs');
+
+const server = new APIServer({ port: 3000 });
+const routeDirectoryLoader = new RouteDirectoryLoader();
+
+routeDirectoryLoader.loadRoutesFromDirectory(server, './routes')
+  .then(routes => {
+    console.log(`${routes.length} rutas cargadas`);
+    server.start();
+  })
+  .catch(error => console.error('Error:', error.message));
+```
+
+```json
+// routes/ejemplos-routes.json
+[
+  {
+    "path": "/api/ejemplos",
+    "method": "GET",
+    "controller": "./controllers/EjemploController.js",
+    "handler": "index",
+    "contentType": "text/html"
+  },
+  {
+    "path": "/api/ejemplos/:id",
+    "method": "GET",
+    "controller": "./controllers/EjemploController.js",
+    "handler": "show",
+    "contentType": "text/html"
+  }
+]
+```
+
+```json
+// routes/otros-routes.json
+[
+  {
+    "path": "/api/otros",
+    "method": "GET",
+    "controller": "./controllers/OtroController.js",
+    "handler": "index",
+    "contentType": "application/json"
+  }
+]
+```
+
+---
+
+## Sistema de Hooks y Filters
+
+### Registrar Hooks
+
+Los hooks permiten extender la funcionalidad del framework en puntos específicos del ciclo de vida de la aplicación:
+
+```javascript
+// hooks/personalizados.js
+const { hooks } = require('jerkjs');
+
+// Registrar un hook para antes de procesar una solicitud
+hooks.addAction('request_received', (req, res) => {
+  console.log(`Solicitud recibida: ${req.method} ${req.url}`);
+});
+
+// Registrar un hook para después de encontrar una ruta
+hooks.addAction('route_matched', (matchedRoute, req, res) => {
+  console.log(`Ruta encontrada: ${req.method} ${req.url}`);
+  console.log(`Handler: ${matchedRoute.route.handler.name}`);
+});
+
+// Registrar un hook para antes de ejecutar un handler de ruta
+hooks.addAction('before_route_handler', async (req, res, next) => {
+  // Puedes modificar req/res o detener la ejecución
+  console.log('Antes de ejecutar handler de ruta');
+  next(); // Continuar con la ejecución
+});
+
+// Registrar un hook para después de ejecutar un handler de ruta
+hooks.addAction('after_route_handler', (req, res) => {
+  console.log('Después de ejecutar handler de ruta');
+});
+
+// Registrar un hook personalizado
+hooks.addAction('mi_hook_personalizado', (datos) => {
+  console.log('Hook personalizado ejecutado con:', datos);
+});
+
+// Disparar el hook personalizado
+hooks.doAction('mi_hook_personalizado', { mensaje: 'Hola Mundo' });
+```
+
+### Registrar Filters
+
+Los filters permiten modificar datos en diferentes puntos del flujo de la aplicación:
+
+```javascript
+// filters/personalizados.js
+const { hooks } = require('jerkjs');
+
+// Registrar un filter para modificar el cuerpo de la solicitud
+hooks.addFilter('request_body', (body, req) => {
+  // Agregar timestamp al cuerpo de la solicitud
+  if (typeof body === 'object') {
+    body.timestamp = new Date().toISOString();
+  }
+  return body;
+});
+
+// Registrar un filter para modificar la respuesta
+hooks.addFilter('response_data', (data, res) => {
+  // Agregar información de metadata a la respuesta
+  if (typeof data === 'object') {
+    data.meta = {
+      timestamp: new Date().toISOString(),
+      version: '2.5.3'
+    };
+  }
+  return data;
+});
+
+// Registrar un filter para transformar datos del modelo antes de guardar
+hooks.addFilter('model_before_save', (data, modelName) => {
+  // Normalizar datos antes de guardar
+  if (data.nombre) {
+    data.nombre = data.nombre.trim().toUpperCase();
+  }
+  return data;
+});
+
+// Registrar un filter para transformar datos del modelo después de leer
+hooks.addFilter('model_after_read', (data, modelName) => {
+  // Transformar datos después de leer
+  if (data.fecha_creacion) {
+    data.fecha_formateada = new Date(data.fecha_creacion).toLocaleDateString();
+  }
+  return data;
+});
+
+// Ejemplo de uso de filter
+const datosOriginales = { nombre: '  juan perez  ' };
+const datosFiltrados = hooks.applyFilters('model_before_save', datosOriginales, 'UsuarioModel');
+console.log(datosFiltrados); // { nombre: 'JUAN PEREZ' }
+```
+
+---
+
+## Creación de Extensiones
+
+Las extensiones permiten extender la funcionalidad del framework con componentes personalizados:
+
+### 1. Extensiones de Middleware
+
+```javascript
+// extensions/ejemplo-middleware.js
+class EjemploMiddleware {
+  /**
+   * Middleware para autenticación personalizada
+   */
+  static authMiddleware(opciones = {}) {
+    return (req, res, next) => {
+      // Verificar token de autenticación
+      const token = req.headers.authorization?.replace('Bearer ', '');
+      
+      if (!token) {
+        res.writeHead(401, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'Token de autenticación requerido' }));
+        return;
+      }
+      
+      // Validar token (implementación simulada)
+      if (token === 'valid-token') {
+        req.usuarioAutenticado = { id: 1, nombre: 'Usuario' };
+        next();
+      } else {
+        res.writeHead(401, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'Token inválido' }));
+      }
+    };
+  }
+  
+  /**
+   * Middleware para logging de solicitudes
+   */
+  static loggingMiddleware(logger) {
+    return (req, res, next) => {
+      const startTime = Date.now();
+      
+      // Interceptamos res.end para medir tiempo
+      const originalEnd = res.end;
+      res.end = function(chunk, encoding) {
+        const duration = Date.now() - startTime;
+        logger.info(`${req.method} ${req.url} - ${duration}ms`);
+        originalEnd.call(this, chunk, encoding);
+      };
+      
+      next();
+    };
+  }
+}
+
+module.exports = EjemploMiddleware;
+```
+
+### 2. Extensiones de Adaptador de Base de Datos
+
+```javascript
+// extensions/custom-db-adapter.js
+class CustomDBAdapter {
+  constructor(configuracion) {
+    this.config = configuracion;
+    // Inicializar conexión a base de datos personalizada
+  }
+  
+  async connect() {
+    // Lógica para conectar a la base de datos
+    console.log('Conectando a base de datos personalizada...');
+  }
+  
+  async disconnect() {
+    // Lógica para desconectar de la base de datos
+    console.log('Desconectando de base de datos personalizada...');
+  }
+  
+  async select(tabla, condiciones = {}, opciones = {}) {
+    // Lógica para selección de datos
+    console.log(`SELECT * FROM ${tabla}`, condiciones);
+    return [];
+  }
+  
+  async insert(tabla, datos) {
+    // Lógica para inserción de datos
+    console.log(`INSERT INTO ${tabla}`, datos);
+    return { id: 1 };
+  }
+  
+  async update(tabla, condiciones, datos) {
+    // Lógica para actualización de datos
+    console.log(`UPDATE ${tabla} SET`, datos, 'WHERE', condiciones);
+    return 1;
+  }
+  
+  async delete(tabla, condiciones) {
+    // Lógica para eliminación de datos
+    console.log(`DELETE FROM ${tabla} WHERE`, condiciones);
+    return 1;
+  }
+  
+  async query(sql, params = []) {
+    // Lógica para consultas personalizadas
+    console.log('QUERY:', sql, params);
+    return [];
+  }
+}
+
+module.exports = CustomDBAdapter;
+```
+
+### 3. Extensiones de Motor de Plantillas
+
+```javascript
+// extensions/custom-template-engine.js
+const fs = require('fs');
+const path = require('path');
+
+class CustomTemplateEngine {
+  constructor(opciones = {}) {
+    this.viewsPath = opciones.viewsPath || './views';
+    this.cacheEnabled = opciones.cacheEnabled || false;
+    this.cache = new Map();
+  }
+  
+  /**
+   * Renderiza una plantilla con datos
+   */
+  render(nombrePlantilla, datos = {}) {
+    const rutaPlantilla = path.join(this.viewsPath, nombrePlantilla + '.html');
+    
+    // Verificar cache si está habilitado
+    if (this.cacheEnabled && this.cache.has(rutaPlantilla)) {
+      const cachedTemplate = this.cache.get(rutaPlantilla);
+      return this.procesarPlantilla(cachedTemplate, datos);
+    }
+    
+    // Leer archivo de plantilla
+    let contenidoPlantilla = fs.readFileSync(rutaPlantilla, 'utf8');
+    
+    // Almacenar en cache si está habilitado
+    if (this.cacheEnabled) {
+      this.cache.set(rutaPlantilla, contenidoPlantilla);
+    }
+    
+    return this.procesarPlantilla(contenidoPlantilla, datos);
+  }
+  
+  /**
+   * Procesa la plantilla reemplazando variables
+   */
+  procesarPlantilla(plantilla, datos) {
+    let resultado = plantilla;
+    
+    // Reemplazar variables simples: {{variable}}
+    for (const [clave, valor] of Object.entries(datos)) {
+      const regex = new RegExp(`{{\\s*${clave}\\s*}}`, 'g');
+      resultado = resultado.replace(regex, valor);
+    }
+    
+    // Procesar bucles: {{#each arreglo}}...{{/each}}
+    const eachRegex = /{{#each\s+(\w+)\s*}}([\s\S]*?){{\/each}}/g;
+    resultado = resultado.replace(eachRegex, (match, arregloNombre, contenido) => {
+      const arreglo = datos[arregloNombre];
+      if (!Array.isArray(arreglo)) return '';
+      
+      let items = '';
+      for (const item of arreglo) {
+        let itemTemplate = contenido;
+        for (const [clave, valor] of Object.entries(item)) {
+          const regex = new RegExp(`{{\\s*${clave}\\s*}}`, 'g');
+          itemTemplate = itemTemplate.replace(regex, valor);
+        }
+        items += itemTemplate;
+      }
+      return items;
+    });
+    
+    return resultado;
+  }
+  
+  /**
+   * Limpia el cache de plantillas
+   */
+  clearCache() {
+    this.cache.clear();
+  }
+}
+
+module.exports = CustomTemplateEngine;
+```
+
+### 4. Extensiones de Componente del Framework
+
+```javascript
+// extensions/custom-component.js
+const { hooks } = require('jerkjs');
+
+class CustomComponent {
+  constructor(servidor, opciones = {}) {
+    this.servidor = servidor;
+    this.opciones = opciones;
+    this.inicializado = false;
+    
+    // Registrar hooks para este componente
+    this.registrarHooks();
+  }
+  
+  /**
+   * Inicializa el componente
+   */
+  async inicializar() {
+    if (this.inicializado) return;
+    
+    console.log('Inicializando componente personalizado...');
+    
+    // Registrar rutas personalizadas
+    this.servidor.addRoute('GET', '/api/custom/status', this.getStatus.bind(this));
+    this.servidor.addRoute('POST', '/api/custom/action', this.performAction.bind(this));
+    
+    this.inicializado = true;
+  }
+  
+  /**
+   * Hook para registrar hooks del componente
+   */
+  registrarHooks() {
+    hooks.addAction('server_started', (servidor) => {
+      console.log('Componente personalizado activo');
+    });
+    
+    hooks.addAction('request_received', (req, res) => {
+      // Agregar encabezado personalizado a todas las respuestas
+      res.customHeaderAdded = true;
+    });
+  }
+  
+  /**
+   * Endpoint para obtener estado del componente
+   */
+  async getStatus(req, res) {
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({
+      status: 'activo',
+      componente: 'CustomComponent',
+      inicializado: this.inicializado,
+      timestamp: new Date().toISOString()
+    }));
+  }
+  
+  /**
+   * Endpoint para realizar acciones personalizadas
+   */
+  async performAction(req, res) {
+    try {
+      const datos = req.body;
+      
+      // Realizar acción personalizada
+      const resultado = await this.ejecutarAccion(datos);
+      
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({
+        success: true,
+        resultado: resultado
+      }));
+    } catch (error) {
+      res.writeHead(500, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({
+        error: error.message
+      }));
+    }
+  }
+  
+  /**
+   * Método para ejecutar acciones personalizadas
+   */
+  async ejecutarAccion(datos) {
+    // Lógica personalizada aquí
+    return {
+      mensaje: 'Acción ejecutada exitosamente',
+      datos: datos,
+      timestamp: new Date().toISOString()
+    };
+  }
+}
+
+module.exports = CustomComponent;
+```
+
+### 5. Uso de Extensiones en la Aplicación
+
+```javascript
+// app.js - Ejemplo de uso de extensiones
+const { APIServer, RouteLoader, ModelManager, MemoryAdapter } = require('jerkjs');
+const EjemploMiddleware = require('./extensions/ejemplo-middleware');
+const CustomDBAdapter = require('./extensions/custom-db-adapter');
+const CustomTemplateEngine = require('./extensions/custom-template-engine');
+const CustomComponent = require('./extensions/custom-component');
+
+// Crear servidor
+const server = new APIServer({
+  port: 3000,
+  host: 'localhost'
+});
+
+// Configurar motor de vistas personalizado
+server.viewEngine = new CustomTemplateEngine({
+  viewsPath: './views',
+  cacheEnabled: true
+});
+
+// Configurar sistema de modelos
+const modelManager = new ModelManager();
+const memoryAdapter = new MemoryAdapter();
+modelManager.registerAdapter('memory', memoryAdapter);
+server.modelManager = modelManager;
+
+// Aplicar middleware personalizado
+server.use(EjemploMiddleware.loggingMiddleware(console));
+server.use(EjemploMiddleware.authMiddleware());
+
+// Inicializar componente personalizado
+const customComponent = new CustomComponent(server);
+customComponent.inicializar();
+
+// Cargar rutas
+const routeLoader = new RouteLoader();
+routeLoader.loadRoutes(server, './routes.json')
+  .then(() => {
+    server.start();
+    console.log('Aplicación iniciada con extensiones personalizadas');
+  })
+  .catch(error => {
+    console.error('Error iniciando aplicación:', error.message);
+  });
+```
+
+---
+
+## Buenas Prácticas
+
+1. **Organización de Código**: Mantener una estructura de directorios clara (controllers, models, views, extensions)
+2. **Reutilización**: Aprovechar la herencia de `ControllerBase` y `ModelBase`
+3. **Seguridad**: Validar entradas y usar middleware de autenticación
+4. **Rendimiento**: Usar cacheo de vistas y conexiones a base de datos
+5. **Mantenibilidad**: Documentar extensiones y seguir convenciones de nomenclatura
+
+Este manual proporciona una guía completa para desarrollar aplicaciones MVC en JERK Framework, desde la creación de componentes básicos hasta la implementación de extensiones avanzadas.