jerkjs 2.0.0

package/examples/v2.1_firewall_demo/README.md

@@ -0,0 +1,113 @@
+# Ejemplo de API con Funcionalidades de Firewall Avanzado (v2.1.0)
+
+Este ejemplo demuestra las funcionalidades de firewall avanzado implementadas en la versión 2.1.0 del Framework API SDK, incluyendo el sistema de hooks para eventos de seguridad.
+
+## Características del Firewall
+
+- **Detección de Patrones de Ataque**: Identificación de SQL Injection, XSS, Path Traversal
+- **Bloqueo de IPs**: Sistema de bloqueo tras múltiples intentos fallidos
+- **Listas Blancas y Negras**: IPs permitidas o prohibidas permanentemente
+- **Reglas Personalizadas**: Posibilidad de definir reglas personalizadas de firewall
+- **Sistema de Hooks**: Integración con el sistema de hooks para eventos de seguridad
+- **Monitoreo de Solicitudes Sospechosas**: Registro y seguimiento de actividades sospechosas
+
+## Configuración
+
+No se requieren dependencias adicionales más allá del Framework API SDK.
+
+## Uso
+
+1. Inicia el servidor:
+   ```bash
+   node app.js
+   ```
+
+2. El servidor escuchará en `http://localhost:8097`
+
+## Endpoints de Prueba
+
+- `GET /` - Página de inicio con información del firewall
+- `GET /test-attacks` - Prueba de detección de ataques
+- `GET /test-sql-injection` - Prueba de detección de SQL injection (será bloqueada)
+- `GET /test-xss` - Prueba de detección de XSS (será bloqueada)
+- `GET /test-path-traversal` - Prueba de detección de path traversal (será bloqueada)
+- `GET /firewall-status` - Estado actual del firewall
+
+## Pruebas de Seguridad
+
+### Prueba de SQL Injection
+```bash
+curl -X GET "http://localhost:8097/test-sql-injection?id=1'%20OR%20'1'='1"
+```
+
+### Prueba de XSS
+```bash
+curl -X GET "http://localhost:8097/test-xss?input=<script>alert('xss')</script>"
+```
+
+### Prueba de Path Traversal
+```bash
+curl -X GET "http://localhost:8097/test-path-traversal?file=../../../etc/passwd"
+```
+
+### Prueba de User Agent Sospechoso
+```bash
+curl -X GET http://localhost:8097/test-attacks -H "User-Agent: sqlmap/1.0"
+```
+
+## Sistema de Hooks de Seguridad
+
+El ejemplo demuestra cómo usar el sistema de hooks para eventos de seguridad:
+
+- `firewall_rule_triggered` - Se dispara cuando se activa una regla de firewall
+- `firewall_ip_blocked` - Se dispara cuando se bloquea una IP
+- `firewall_security_event` - Se dispara para eventos generales de seguridad
+
+## Configuración del Firewall
+
+El firewall se puede configurar con las siguientes opciones:
+
+```javascript
+const firewall = new Firewall({
+  maxAttempts: 5,           // Número máximo de intentos antes de bloquear
+  blockDuration: 900000,    // Duración del bloqueo en ms (15 minutos)
+  whitelist: ['127.0.0.1'], // IPs que no deben ser bloqueadas
+  blacklist: [],            // IPs que siempre deben ser bloqueadas
+  rules: [                  // Reglas personalizadas de firewall
+    {
+      name: 'large_payload',
+      condition: (req) => {
+        // Condición para activar la regla
+      },
+      action: 'block',      // 'block' o 'monitor'
+      reason: 'Motivo del bloqueo'
+    }
+  ],
+  logger: logger            // Instancia de logger para eventos
+});
+```
+
+## Estructura del proyecto
+
+```
+examples/v2.1_firewall_demo/
+├── app.js              # Punto de entrada de la aplicación con firewall
+├── controllers/        # Controladores de las rutas
+│   └── (controladores según sea necesario)
+└── README.md
+```
+
+## Reglas de Firewall Integradas
+
+1. **SQL Injection Detection**: Detecta patrones comunes de inyección SQL
+2. **XSS Detection**: Detecta patrones comunes de Cross-Site Scripting
+3. **Path Traversal**: Detecta intentos de navegación fuera del directorio permitido
+4. **Large Payload**: Bloquea solicitudes con cuerpos excesivamente grandes
+5. **Suspicious User Agents**: Detecta user agents asociados con herramientas de ataque
+
+## Seguridad
+
+- El firewall bloquea automáticamente solicitudes que contienen patrones de ataque conocidos
+- Las IPs que generan múltiples violaciones son bloqueadas temporalmente
+- Las reglas personalizadas permiten una protección adaptada a necesidades específicas
+- El sistema de hooks permite una respuesta personalizada a eventos de seguridad

package/examples/v2.1_firewall_demo/app.js

@@ -0,0 +1,182 @@
+/**
+ * Ejemplo de API con funcionalidades de firewall avanzado (v2.1.0)
+ * Demostrando el uso del sistema de firewall con el sistema de hooks
+ */
+
+const {
+  APIServer,
+  Authenticator,
+  RateLimiter,
+  Logger,
+  HookSystem,
+  Firewall
+} = require('../../index.js');
+
+async function startServer() {
+  // Crear instancia del servidor
+  const server = new APIServer({
+    port: 8097,
+    host: 'localhost'
+  });
+
+  // Crear instancia del logger
+  const logger = new Logger({ level: 'info' });
+
+  // Crear instancia del sistema de hooks
+  const hooks = new HookSystem();
+
+  // Crear instancia del firewall
+  const firewall = new Firewall({
+    maxAttempts: 3,
+    blockDuration: 300000, // 5 minutos para pruebas
+    whitelist: ['127.0.0.1', '::1'], // IPs locales
+    blacklist: [], // Ninguna IP bloqueada por defecto
+    rules: [
+      {
+        name: 'large_payload',
+        condition: (req) => {
+          // Bloquear solicitudes con cuerpo muy grande
+          const contentLength = req.headers['content-length'];
+          return contentLength && parseInt(contentLength) > 1024 * 100; // 100KB
+        },
+        action: 'block',
+        reason: 'Solicitud con payload excesivamente grande'
+      },
+      {
+        name: 'suspicious_user_agent',
+        condition: (req) => {
+          const userAgent = req.headers['user-agent'] || '';
+          // Detectar user agents sospechosos
+          const suspiciousAgents = [
+            /sqlmap/i,
+            /nikto/i,
+            /nessus/i,
+            /nmap/i,
+            /dirbuster/i
+          ];
+
+          return suspiciousAgents.some(agent => agent.test(userAgent));
+        },
+        action: 'block',
+        reason: 'User agent sospechoso detectado'
+      }
+    ],
+    logger
+  });
+
+  try {
+    // Registrar hooks para eventos de firewall
+    hooks.addAction('firewall_rule_triggered', (rule, clientIP, req) => {
+      logger.info(`[[FIREWALL-HOOK]] Regla activada: ${rule.name} para IP: ${clientIP}`);
+    });
+
+    hooks.addAction('firewall_ip_blocked', (ip, reason) => {
+      logger.warn(`[[FIREWALL-HOOK]] IP bloqueada: ${ip} por razón: ${reason}`);
+    });
+
+    hooks.addAction('firewall_security_event', (event, details) => {
+      logger.info(`[[FIREWALL-HOOK]] Evento de seguridad: ${event}`, details);
+    });
+
+    // Aplicar middleware de firewall al servidor
+    server.use(firewall.middleware());
+
+    // Ruta pública
+    server.addRoute('GET', '/', (req, res) => {
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({
+        message: 'API con funcionalidades de firewall avanzado (v2.1.0)',
+        features: [
+          'Detección de patrones de ataque (SQL Injection, XSS, Path Traversal)',
+          'Bloqueo de IPs tras intentos fallidos',
+          'Listas blancas y negras de IPs',
+          'Reglas personalizadas de firewall',
+          'Sistema de hooks para eventos de seguridad',
+          'Monitoreo de solicitudes sospechosas'
+        ],
+        firewallStatus: firewall.getStatus(),
+        timestamp: new Date().toISOString()
+      }));
+    });
+
+    // Ruta para probar diferentes tipos de ataques
+    server.addRoute('GET', '/test-attacks', (req, res) => {
+      // Disparar un hook personalizado para demostrar el sistema
+      hooks.doAction('firewall_security_event', 'attack_test_requested', {
+        clientIP: firewall.getClientIP(req),
+        userAgent: req.headers['user-agent'],
+        timestamp: new Date().toISOString()
+      });
+
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ 
+        message: 'Prueba de ataques completada',
+        clientIP: firewall.getClientIP(req),
+        securityLevel: 'monitored',
+        timestamp: new Date().toISOString()
+      }));
+    });
+
+    // Ruta para probar SQL injection (esta debería ser bloqueada)
+    server.addRoute('GET', '/test-sql-injection', (req, res) => {
+      // Esta ruta no debería ser accesible si se detecta SQL injection en la URL
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ 
+        message: '¡Esto no debería verse si se detectó SQL injection!',
+        status: 'compromised',
+        timestamp: new Date().toISOString()
+      }));
+    });
+
+    // Ruta para probar XSS (esta debería ser bloqueada)
+    server.addRoute('GET', '/test-xss', (req, res) => {
+      // Esta ruta no debería ser accesible si se detecta XSS en la URL
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ 
+        message: '¡Esto no debería verse si se detectó XSS!',
+        status: 'compromised',
+        timestamp: new Date().toISOString()
+      }));
+    });
+
+    // Ruta para probar path traversal (esta debería ser bloqueada)
+    server.addRoute('GET', '/test-path-traversal', (req, res) => {
+      // Esta ruta no debería ser accesible si se detecta path traversal
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ 
+        message: '¡Esto no debería verse si se detectó path traversal!',
+        status: 'compromised',
+        timestamp: new Date().toISOString()
+      }));
+    });
+
+    // Ruta para verificar estado del firewall
+    server.addRoute('GET', '/firewall-status', (req, res) => {
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({
+        firewall: firewall.getStatus(),
+        timestamp: new Date().toISOString()
+      }));
+    });
+
+    // Iniciar el servidor
+    server.start();
+
+    logger.info('Servidor con firewall avanzado iniciado en http://localhost:8097');
+    logger.info('Endpoints disponibles:');
+    logger.info('- GET / - Página de inicio con información de firewall');
+    logger.info('- GET /test-attacks - Prueba de detección de ataques');
+    logger.info('- GET /test-sql-injection - Prueba de detección de SQL injection (será bloqueada)');
+    logger.info('- GET /test-xss - Prueba de detección de XSS (será bloqueada)');
+    logger.info('- GET /test-path-traversal - Prueba de detección de path traversal (será bloqueada)');
+    logger.info('- GET /firewall-status - Estado actual del firewall');
+  } catch (error) {
+    logger.error('Error iniciando el servidor:', error.message);
+    process.exit(1);
+  }
+}
+
+// Iniciar el servidor
+startServer();
+
+module.exports = { startServer };

package/examples/v2.1_firewall_demo/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "api-sdk-firewall-demo",
+  "version": "1.0.0",
+  "description": "Ejemplo de API con funcionalidades de firewall avanzado usando el Framework API SDK",
+  "main": "app.js",
+  "scripts": {
+    "start": "node app.js",
+    "dev": "nodemon app.js"
+  },
+  "keywords": [
+    "api",
+    "sdk",
+    "firewall",
+    "security",
+    "advanced",
+    "protection",
+    "framework"
+  ],
+  "author": "API SDK Framework",
+  "license": "MIT",
+  "dependencies": {
+    "jsonwebtoken": "^9.0.0"
+  },
+  "devDependencies": {
+    "nodemon": "^3.0.0"
+  }
+}

package/examples/v2.1_hooks_demo/README.md

@@ -0,0 +1,85 @@
+# Ejemplo de Sistema de Hooks en Framework API SDK
+
+Este ejemplo demuestra cómo usar el sistema de hooks como el core de WordPress para extender la funcionalidad del Framework API SDK en diferentes puntos del ciclo de vida.
+
+## Características del Sistema de Hooks
+
+- **Acciones (Actions)**: Puntos de extensión donde se pueden ejecutar funciones
+- **Filtros (Filters)**: Puntos donde se pueden modificar datos antes de ser procesados
+- **Extensibilidad**: Capacidad para agregar funcionalidades en múltiples puntos del ciclo de vida
+- **Ciclo de Vida**: Hooks disponibles en diferentes etapas del proceso
+
+## Hooks Disponibles
+
+### Hooks de Servidor
+- `framework_init`: Se ejecuta cuando se inicializa el framework
+- `pre_server_start`: Antes de iniciar el servidor
+- `post_server_start`: Después de iniciar el servidor
+
+### Hooks de Carga de Rutas
+- `pre_route_load`: Antes de cargar rutas desde archivo
+- `post_route_load`: Después de cargar rutas desde archivo
+
+### Hooks de Carga de Controladores
+- `pre_controller_load`: Antes de cargar un controlador
+- `post_controller_load`: Después de cargar un controlador
+
+## Configuración
+
+No se requieren dependencias adicionales más allá del Framework API SDK.
+
+## Uso
+
+1. Inicia el servidor:
+   ```bash
+   node app.js
+   ```
+
+2. El servidor escuchará en `http://localhost:8096`
+
+## Endpoints
+
+- `GET /` - Página de inicio con información del sistema de hooks
+- `GET /hooks-info` - Información sobre el sistema de hooks
+
+## Ejemplo de uso de Hooks
+
+```javascript
+const { hooks } = require('jerk');
+
+// Registrar una acción
+hooks.addAction('nombre_del_hook', (param1, param2) => {
+  console.log('Hook ejecutado con:', param1, param2);
+});
+
+// Registrar un filtro
+hooks.addFilter('nombre_del_filtro', (valor, parametroAdicional) => {
+  return valor + parametroAdicional;
+});
+
+// Ejecutar una acción
+hooks.doAction('nombre_del_hook', 'dato1', 'dato2');
+
+// Aplicar un filtro
+const resultado = hooks.applyFilters('nombre_del_filtro', 'valorInicial', 'datoAdicional');
+```
+
+## Estructura del proyecto
+
+```
+examples/v2.1_hooks_demo/
+├── app.js              # Punto de entrada de la aplicación con hooks
+├── routes.json         # Definición de rutas
+├── controllers/        # Controladores de las rutas
+│   ├── mainController.js
+│   └── hooksController.js
+└── README.md
+```
+
+## Beneficios del Sistema de Hooks
+
+1. **Extensibilidad**: Permite extender la funcionalidad sin modificar el código base
+2. **Modularidad**: Módulos pueden añadir funcionalidades sin interferir entre sí
+3. **Flexibilidad**: Hooks disponibles en múltiples puntos del ciclo de vida
+4. **Personalización**: Capacidad para modificar comportamientos predeterminados
+5. **Integración**: Fácil integración con sistemas de terceros

package/examples/v2.1_hooks_demo/app.js

@@ -0,0 +1,101 @@
+/**
+ * Ejemplo de uso del sistema de hooks en el Framework API SDK
+ * Demostrando extensibilidad en diferentes puntos del ciclo de vida
+ */
+
+const jerk = require('../../index.js');
+const {
+  APIServer,
+  Logger
+} = jerk;
+const RouteLoader = require('../../lib/loader/routeLoader.js');
+const ControllerLoader = require('../../lib/loader/controllerLoader.js');
+const hooks = jerk.hooks;
+
+async function startServer() {
+  // Crear instancia del servidor
+  const server = new APIServer({
+    port: 8096,
+    host: 'localhost'
+  });
+
+  // Crear instancia del logger
+  const logger = new Logger({ level: 'info' });
+
+  try {
+    // Registrar hooks para diferentes eventos del ciclo de vida
+
+    // Hook que se ejecuta cuando se inicializa el framework
+    hooks.addAction('framework_init', () => {
+      logger.info('[[FRAMEWORK]] - El framework ha sido inicializado');
+    });
+
+    // Hook que se ejecuta antes de iniciar el servidor
+    hooks.addAction('pre_server_start', (serverInstance) => {
+      logger.info('[[HOOK]] - Antes de iniciar el servidor');
+      logger.info('[[HOOK]] - Puerto configurado:', serverInstance.port);
+    });
+
+    // Hook que se ejecuta después de iniciar el servidor
+    hooks.addAction('post_server_start', (serverInstance) => {
+      logger.info('[[HOOK]] - Servidor iniciado exitosamente');
+      logger.info('[[HOOK]] - Escuchando en:', `http://${serverInstance.host}:${serverInstance.port}`);
+    });
+
+    // Hook que se ejecuta antes de cargar rutas
+    hooks.addAction('pre_route_load', (filePath, serverInstance) => {
+      logger.info('[[HOOK]] - A punto de cargar rutas desde:', filePath);
+    });
+
+    // Hook que se ejecuta después de cargar rutas
+    hooks.addAction('post_route_load', (routes, serverInstance) => {
+      logger.info('[[HOOK]] - Rutas cargadas exitosamente:', routes.length, 'rutas');
+      routes.forEach((route, index) => {
+        logger.info(`[[HOOK]] - Ruta ${index + 1}: ${route.method} ${route.path}`);
+      });
+    });
+
+    // Hook que se ejecuta antes de cargar un controlador
+    hooks.addAction('pre_controller_load', (controllerPath) => {
+      logger.info('[[HOOK]] - A punto de cargar controlador:', controllerPath);
+    });
+
+    // Hook que se ejecuta después de cargar un controlador
+    hooks.addAction('post_controller_load', (controllerModule, absolutePath) => {
+      logger.info('[[HOOK]] - Controlador cargado exitosamente:', absolutePath);
+      // Podríamos inspeccionar las funciones disponibles en el módulo
+      const availableHandlers = Object.keys(controllerModule).filter(key => 
+        typeof controllerModule[key] === 'function'
+      );
+      logger.info('[[HOOK]] - Handlers disponibles en el controlador:', availableHandlers);
+    });
+
+    // Ejemplo de uso de filtros
+    hooks.addFilter('modify_response_data', (data, endpoint) => {
+      // Añadir información de auditoría a todas las respuestas
+      return {
+        ...data,
+        _hook_processed: true,
+        _timestamp: new Date().toISOString(),
+        _endpoint: endpoint
+      };
+    });
+
+    // Cargar rutas desde archivo JSON
+    const routeLoader = new RouteLoader();
+    await routeLoader.loadRoutes(server, './routes.json');
+
+    // Iniciar el servidor
+    server.start();
+
+    logger.info('Servidor iniciado con sistema de hooks activo');
+  } catch (error) {
+    logger.error('Error iniciando el servidor:', error.message);
+    process.exit(1);
+  }
+}
+
+// Iniciar el servidor
+startServer();
+
+module.exports = { startServer };

package/examples/v2.1_hooks_demo/controllers/hooksController.js

@@ -0,0 +1,29 @@
+const jerk = require('../../../index.js');
+const hooks = jerk.hooks;
+
+const hooksController = {
+  getHooksInfo: (req, res) => {
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ 
+      message: 'Información sobre el sistema de hooks',
+      hooksSystem: {
+        'actionsRegistradas': hooks.actions ? hooks.actions.size : 0,
+        'filtersRegistrados': hooks.filters ? hooks.filters.size : 0,
+        'accionesDisponibles': [
+          'framework_init',
+          'pre_server_start',
+          'post_server_start',
+          'pre_route_load',
+          'post_route_load',
+          'pre_controller_load',
+          'post_controller_load'
+        ],
+        'ejemploUso': 'hooks.addAction(nombreHook, funcionCallback)',
+        'ejemploFiltro': 'hooks.addFilter(nombreFiltro, funcionCallback)'
+      },
+      timestamp: new Date().toISOString()
+    }));
+  }
+};
+
+module.exports = hooksController;

package/examples/v2.1_hooks_demo/controllers/mainController.js

@@ -0,0 +1,18 @@
+const mainController = {
+  home: (req, res) => {
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ 
+      message: 'API con sistema de hooks activo',
+      features: [
+        'Pre/Post hooks para carga de rutas',
+        'Pre/Post hooks para carga de controladores',
+        'Pre/Post hooks para inicio de servidor',
+        'Filtros para modificar datos de respuesta',
+        'Extensibilidad en múltiples puntos del ciclo de vida'
+      ],
+      timestamp: new Date().toISOString()
+    }));
+  }
+};
+
+module.exports = mainController;

package/examples/v2.1_hooks_demo/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "api-sdk-hooks-demo",
+  "version": "1.0.0",
+  "description": "Ejemplo de API con sistema de hooks para extensibilidad usando el Framework API SDK",
+  "main": "app.js",
+  "scripts": {
+    "start": "node app.js",
+    "dev": "nodemon app.js"
+  },
+  "keywords": [
+    "api",
+    "sdk",
+    "hooks",
+    "filters",
+    "extensibility",
+    "wordpress",
+    "framework"
+  ],
+  "author": "API SDK Framework",
+  "license": "MIT",
+  "dependencies": {
+    "jsonwebtoken": "^9.0.0"
+  },
+  "devDependencies": {
+    "nodemon": "^3.0.0"
+  }
+}

package/examples/v2.1_hooks_demo/routes.json

@@ -0,0 +1,16 @@
+[
+  {
+    "path": "/",
+    "method": "GET",
+    "controller": "./controllers/mainController.js",
+    "handler": "home",
+    "auth": "none"
+  },
+  {
+    "path": "/hooks-info",
+    "method": "GET",
+    "controller": "./controllers/hooksController.js",
+    "handler": "getHooksInfo",
+    "auth": "none"
+  }
+]

package/examples/v2.1_openapi_demo/README.md

@@ -0,0 +1,82 @@
+# Ejemplo API con Funcionalidades OpenAPI (v2.1.0)
+
+Este ejemplo demuestra cómo crear una API con funcionalidades OpenAPI integradas utilizando el Framework API SDK.
+
+## Características de OpenAPI
+
+- **Generación automática de documentación OpenAPI 3.0**
+- **Interfaz Swagger UI interactiva**
+- **Definición de esquemas de datos**
+- **Documentación de seguridad y autenticación**
+- **Especificación de endpoints, parámetros y respuestas**
+- **Soporte para diferentes formatos de contenido**
+- **Validación de peticiones y respuestas**
+
+## Configuración
+
+No se requieren dependencias adicionales más allá del Framework API SDK.
+
+## Uso
+
+1. Inicia el servidor:
+   ```bash
+   node app.js
+   ```
+
+2. El servidor escuchará en `http://localhost:8096`
+
+## Endpoints
+
+- `GET /` - Página de inicio con información de OpenAPI
+- `POST /login` - Iniciar sesión y obtener token
+- `GET /users` - Lista de usuarios (requiere token)
+- `GET /products` - Lista de productos (requiere token)
+- `GET /docs` - Documentación interactiva OpenAPI/Swagger
+- `GET /openapi.json` - Especificación OpenAPI
+
+## Ejemplo de uso
+
+1. Iniciar sesión:
+   ```bash
+   curl -X POST http://localhost:8096/login \
+     -H "Content-Type: application/json" \
+     -d '{"username": "admin", "password": "password"}'
+   ```
+
+2. Acceder a usuarios con el token:
+   ```bash
+   curl -X GET http://localhost:8096/users \
+     -H "Authorization: Bearer TU_TOKEN_AQUI"
+   ```
+
+3. Ver documentación interactiva:
+   Visita `http://localhost:8096/docs` en tu navegador
+
+4. Obtener especificación OpenAPI:
+   ```bash
+   curl -X GET http://localhost:8096/openapi.json
+   ```
+
+## Estructura del proyecto
+
+```
+examples/v2.1_openapi_demo/
+├── app.js              # Punto de entrada de la aplicación
+├── controllers/        # Controladores de las rutas
+│   ├── mainController.js
+│   ├── authController.js
+│   ├── userController.js
+│   └── productController.js
+└── README.md
+```
+
+## Documentación OpenAPI
+
+El framework genera automáticamente:
+
+- Una especificación OpenAPI 3.0 en `/openapi.json`
+- Una interfaz Swagger UI interactiva en `/docs`
+- Esquemas de datos definidos para reutilización
+- Documentación detallada de endpoints, parámetros y respuestas
+- Soporte para diferentes códigos de respuesta HTTP
+- Definición de esquemas de seguridad