blackcoffee2 2.1.0

package/manuales/modulos_administracion.md

@@ -0,0 +1,89 @@
+# Documentación de Módulos del Sistema de Administración
+
+Este documento describe los módulos disponibles en el servidor de administración del framework Insitu.
+
+## Módulos Disponibles
+
+### 1. Routes Module (`routes`)
+- **Descripción**: Módulo para ver rutas registradas y activas
+- **Comandos**: `routes`, `active`
+
+### 2. System Module (`system`)
+- **Descripción**: Módulo para información del sistema
+- **Comandos**: `version`, `status`, `help`
+
+### 3. Cache Module (`cachemodule`)
+- **Descripción**: Módulo para administrar y monitorear el sistema de caché
+- **Comandos**: `cache`, `cache-stats`, `cache-clear`, `cache-info`
+
+### 4. Queue Management Module (`queuemanagementmodule`)
+- **Descripción**: Módulo para gestionar las colas del sistema
+- **Comandos**: `queues`, `queue-info`, `queue-pause`, `queue-resume`, `queue-clear`, `queue-retry-failed`
+
+### 5. Route Cache Module (`routecachemodule`)
+- **Descripción**: Módulo para gestionar y visualizar el cache de rutas dinámicas y estáticas
+- **Comandos**: `route-cache`, `cache-stats`, `cache-view`, `cache-clear`, `cache-dynamic`, `cache-static`
+
+### 6. Route Manager Module (`routemanagermodule`)
+- **Descripción**: Módulo para crear y deshabilitar rutas de manera interactiva
+- **Comandos**: `manage-routes`, `route-manager`, `route-mgmt`
+
+### 7. Stats Module (`statsmodule`)
+- **Descripción**: Módulo para mostrar estadísticas del servidor
+- **Comandos**: `stats`, `statistics`, `requests`, `endpoints`
+
+### 8. System Module (`systemmodule`)
+- **Descripción**: Módulo para mostrar información del sistema
+- **Comandos**: `sysinfo`, `system`, `resources`
+
+### 9. Time Module (`timemodule`)
+- **Descripción**: Módulo para mostrar hora y fecha
+- **Comandos**: `time`, `date`
+
+### 10. View Cache Stats Module (`viewcachestatsmodule`)
+- **Descripción**: Módulo para mostrar estadísticas del caché de vistas
+- **Comandos**: `view-cache`
+
+### 11. WAF Module (`wafmodule`)
+- **Descripción**: Módulo para mostrar estadísticas del Web Application Firewall
+- **Comandos**: `waf-status`, `waf-stats`, `waf-blocked`, `waf-security`, `waf-block-ip`, `waf-unblock-ip`, `waf-whitelist`, `waf-blacklist`, `waf-x-headers`, `create-x-rule`, `remove-x-rule`, `save-rules`, `load-rules`, `waf-logs`, `waf-monitored`
+
+## Conexión al Servidor de Administración
+
+Existen dos formas principales de conectarte al servidor de administración:
+
+### 1. Usando Netcat (nc)
+Para conectarte al servidor de administración, usa el siguiente comando:
+
+```bash
+nc localhost 9999
+```
+
+Una vez conectado, puedes usar cualquiera de los comandos mencionados arriba para interactuar con los diferentes módulos.
+
+### 2. Usando el Cliente Oficial de Administración
+El framework también incluye un cliente CLI especializado para interactuar con el servidor de administración:
+
+```bash
+node icca.js
+```
+
+Este cliente ofrece características adicionales como:
+- Historial de comandos
+- Autocompletado de comandos
+- Reutilización de comandos anteriores
+- Comandos especiales del cliente:
+  - `history`: Muestra el historial de comandos
+  - `clear`: Limpia la pantalla
+  - `re <número>`: Reutiliza el comando número n del historial
+  - `re <texto>`: Reutiliza el último comando que contiene el texto
+  - `help-cli`: Muestra ayuda del cliente
+
+Opciones de conexión:
+- `-h, --host HOST`: Especifica el host del servidor (por defecto: localhost)
+- `-p, --port PORT`: Especifica el puerto del servidor (por defecto: 9999)
+
+Ejemplo:
+```bash
+node icca.js --host localhost --port 9999
+```

package/manuales/router_execution_points.md

@@ -0,0 +1,74 @@
+# Puntos de ejecución en el framework Insitu
+
+## 1. Ejecución del método indicado por el router
+
+El punto exacto donde se ejecuta el handler (método) asociado a una ruta se encuentra en:
+`/home/bds/insitu-js/lib/core/server.js`
+
+Líneas específicas:
+- Línea 906: `await matchedRoute.route.handler(req, res);` (solo para solicitudes OPTIONS)
+- Línea 958: `await matchedRoute.route.handler(req, res);` (para otros métodos HTTP)
+
+Esto ocurre después de que el sistema encuentra una ruta coincidente (`matchedRoute`) y antes de disparar el hook correspondiente (`handleRouteHandlerExecuted`).
+
+### Hooks y filtros disponibles
+
+Después de las modificaciones realizadas, ahora existen hooks y filtros disponibles para la ejecución de handlers en la línea 958 (solicitudes que no sean OPTIONS):
+
+- **Antes de la ejecución del handler** (línea ~965):
+  - Hook de acción: `before_route_handler`
+  - Filtro: `before_route_handler` (permite modificar req/res)
+  
+- **Después de la ejecución del handler** (línea ~975):
+  - Hook de acción: `after_route_handler`
+  - Filtro: `after_route_handler` (permite modificar req/res)
+
+Estos hooks y filtros **no se aplican** a las solicitudes OPTIONS (línea 906).
+
+### Explicación de la duplicación
+
+La duplicación del código `await matchedRoute.route.handler(req, res);` en las líneas 906 y 958 se debe a que hay dos caminos de ejecución diferentes en la función `handleRequest`:
+
+1. **Línea 906**: Se ejecuta en el caso de solicitudes **OPTIONS** que tienen un handler específico registrado para esa ruta. Esta parte del código está dentro de un bloque condicional que maneja específicamente el método HTTP OPTIONS.
+
+2. **Línea 958**: Se ejecuta para otros métodos HTTP (GET, POST, PUT, etc.) que no sean OPTIONS, en el flujo normal de procesamiento de rutas.
+
+El código está estructurado de esta manera para manejar de forma diferente las solicitudes OPTIONS (que son parte del mecanismo CORS) respecto a otros tipos de solicitudes. Las solicitudes OPTIONS pueden requerir un tratamiento especial en el contexto de CORS, por lo que se separaron en diferentes ramas de lógica.
+
+Aunque la instrucción es idéntica en ambos lugares, están en contextos ligeramente diferentes para permitir un manejo específico de solicitudes OPTIONS versus otros métodos HTTP.
+
+## 2. Carga de archivos estáticos
+
+El punto exacto donde se carga un archivo estático se encuentra en el método `createStaticFileHandler` en:
+`/home/bds/insitu-js/lib/core/server.js`
+
+Bloque de código clave para archivos índice (líneas aproximadas 400-415):
+```javascript
+const fileContent = await fs.promises.readFile(indexPath);
+const mimeType = getMimeType(indexPath);
+
+this.setStaticFileHeaders(res, mimeType, staticConfig);
+
+res.writeHead(200);
+res.end(fileContent);
+
+// Disparar hook después de servir archivo
+StaticFileHooksHandler.handleStaticFileServed(this, indexPath, req, res);
+return;
+```
+
+Y también para archivos normales (líneas aproximadas 490-495):
+```javascript
+const fileContent = await fs.promises.readFile(physicalPath);
+const mimeType = getMimeType(physicalPath);
+
+this.setStaticFileHeaders(res, mimeType, staticConfig);
+
+res.writeHead(200);
+res.end(fileContent);
+
+// Disparar hook después de servir archivo
+StaticFileHooksHandler.handleStaticFileServed(this, physicalPath, req, res);
+```
+
+Estos bloques de código se ejecutan cuando una ruta estática coincide con la solicitud y se debe servir un archivo físico desde el sistema de archivos.

package/manuales/static_file_hooks_usage.md

@@ -0,0 +1,222 @@
+# Cómo usar los hooks `before_static_file_load` y `after_static_file_load`
+
+Los hooks `before_static_file_load` y `after_static_file_load` permiten interceptar y manipular la carga de archivos estáticos en el framework Insitu. Estos hooks se ejecutan en ambos puntos donde se cargan archivos estáticos: tanto para archivos normales como para archivos índice (como `index.html`).
+
+## Hook `before_static_file_load`
+
+Este hook se ejecuta justo antes de que se lea un archivo estático del sistema de archivos.
+
+### Ejemplo 1: Uso como acción para registrar accesos
+
+```javascript
+// Registrar cada vez que se va a cargar un archivo estático
+hooks.addAction('before_static_file_load', (req, res, filePath, staticConfig) => {
+  console.log(`Cargando archivo estático: ${filePath}`);
+  console.log(`URL solicitada: ${req.url}`);
+}, 10, 4);
+```
+
+### Ejemplo 2: Uso como filtro para modificar la respuesta
+
+```javascript
+// Añadir headers personalizados antes de cargar el archivo
+hooks.addFilter('before_static_file_load', (data, req, res, filePath, staticConfig) => {
+  // Añadir header para indicar que es un archivo estático
+  res.setHeader('X-Static-File', 'true');
+  
+  // Añadir header con la ruta del archivo
+  res.setHeader('X-File-Path', filePath);
+  
+  // Devolver el objeto modificado
+  return {
+    ...data,
+    res: res
+  };
+}, 10, 4);
+```
+
+### Ejemplo 3: Uso como filtro para implementar autenticación en archivos estáticos
+
+```javascript
+// Verificar permisos antes de servir archivos estáticos
+hooks.addFilter('before_static_file_load', (data, req, res, filePath, staticConfig) => {
+  // Verificar si el archivo está protegido
+  if (isProtectedFile(filePath)) {
+    // Aquí podrías implementar tu lógica de autenticación
+    const isAuthenticated = checkAuthentication(req);
+    
+    if (!isAuthenticated) {
+      // Si no está autenticado, enviar respuesta de error
+      if (!res.headersSent) {
+        res.writeHead(403, { 'Content-Type': 'text/plain' });
+        res.end('Acceso prohibido');
+      }
+      return data; // Retorna sin cargar el archivo
+    }
+  }
+  
+  // Si está autorizado, continuar normalmente
+  return data;
+}, 5, 4);
+```
+
+### Ejemplo 4: Uso como filtro para modificar la configuración estática
+
+```javascript
+// Modificar la configuración estática basada en la solicitud
+hooks.addFilter('before_static_file_load', (data, req, res, filePath, staticConfig) => {
+  // Modificar la configuración basada en el tipo de usuario
+  if (req.userRole === 'admin') {
+    // Permitir acceso a archivos adicionales para administradores
+    const modifiedConfig = {
+      ...staticConfig,
+      // Añadir configuraciones específicas para admins
+    };
+    
+    return {
+      ...data,
+      staticConfig: modifiedConfig
+    };
+  }
+  
+  return data;
+}, 15, 4);
+```
+
+## Hook `after_static_file_load`
+
+Este hook se ejecuta después de que se ha leído el archivo del sistema de archivos pero antes de enviarlo al cliente.
+
+### Ejemplo 1: Uso como acción para registrar métricas
+
+```javascript
+// Registrar cada vez que se completa la carga de un archivo estático
+hooks.addAction('after_static_file_load', (req, res, filePath, staticConfig) => {
+  console.log(`Archivo estático cargado: ${filePath}`);
+  console.log(`Tamaño: ${res.getHeader('Content-Length')} bytes`);
+}, 10, 4);
+```
+
+### Ejemplo 2: Uso como filtro para modificar el contenido del archivo
+
+```javascript
+// Modificar el contenido del archivo antes de enviarlo (solo para ciertos tipos de archivo)
+hooks.addFilter('after_static_file_load', (data, req, res, filePath, staticConfig, fileContent) => {
+  // Solo para archivos HTML
+  if (filePath.endsWith('.html') && !res.headersSent) {
+    // Acceder al contenido del archivo
+    let content = data.fileContent.toString();
+    
+    // Modificar el contenido (por ejemplo, inyectar un script)
+    if (content.includes('</body>')) {
+      content = content.replace('</body>', '<script>console.log("Archivo modificado por el hook");</script></body>');
+    }
+    
+    // Devolver el objeto con el contenido modificado
+    return {
+      ...data,
+      fileContent: Buffer.from(content)
+    };
+  }
+  
+  return data;
+}, 10, 5);
+```
+
+### Ejemplo 2b: Uso con Cheerio para manipulación HTML más avanzada
+
+```javascript
+const cheerio = require('cheerio'); // Necesitas instalar cheerio: npm install cheerio
+
+// Manipular HTML usando Cheerio para inyección de scripts o estilos
+hooks.addFilter('after_static_file_load', (data, req, res, filePath, staticConfig, fileContent) => {
+  // Solo para archivos HTML
+  if (filePath.endsWith('.html') && !res.headersSent) {
+    try {
+      // Convertir el buffer a string y cargarlo en Cheerio
+      const htmlString = data.fileContent.toString();
+      const $ = cheerio.load(htmlString);
+      
+      // Añadir un script al head
+      $('head').append('<script src="/assets/custom-script.js"></script>');
+      
+      // Añadir un estilo personalizado
+      $('body').prepend('<style>.custom-class { color: blue; }</style>');
+      
+      // Devolver el HTML modificado
+      const modifiedHtml = $.html();
+      return {
+        ...data,
+        fileContent: Buffer.from(modifiedHtml)
+      };
+    } catch (error) {
+      console.error('Error al manipular el archivo HTML:', error);
+      // Devolver el contenido original si hay un error
+      return data;
+    }
+  }
+  
+  return data;
+}, 10, 5);
+```
+
+### Ejemplo 3: Uso como filtro para auditoría post-carga
+
+```javascript
+// Registrar información de auditoría después de cargar el archivo
+hooks.addFilter('after_static_file_load', (data, req, res, filePath, staticConfig) => {
+  const auditLog = {
+    timestamp: new Date().toISOString(),
+    userId: req.userId || 'anonymous',
+    filePath: filePath,
+    url: req.url,
+    method: req.method,
+    statusCode: res.statusCode || 200
+  };
+  
+  // Guardar registro de auditoría
+  console.log('STATIC_FILE_AUDIT:', JSON.stringify(auditLog));
+  
+  return data;
+}, 5, 4);
+```
+
+### Ejemplo 4: Uso como filtro para compresión condicional
+
+```javascript
+// Aplicar compresión condicional después de cargar el archivo
+hooks.addFilter('after_static_file_load', (data, req, res, filePath, staticConfig) => {
+  // Verificar si el cliente admite compresión
+  const acceptEncoding = req.headers['accept-encoding'];
+  if (acceptEncoding && acceptEncoding.includes('gzip')) {
+    // Aquí podrías aplicar compresión gzip si el archivo es grande
+    // y el tipo de archivo es apropiado para compresión
+    if (shouldCompressFile(filePath)) {
+      res.setHeader('Content-Encoding', 'gzip');
+    }
+  }
+  
+  return data;
+}, 15, 4);
+```
+
+## Parámetros importantes:
+
+- El hook `before_static_file_load` recibe: `(data, req, res, filePath, staticConfig)` para los filtros
+- El hook `after_static_file_load` recibe: `(data, req, res, filePath, staticConfig, fileContent)` para los filtros
+  - El objeto `data` incluye: `{ req, res, filePath, staticConfig, fileContent }`
+- Las acciones para `before_static_file_load` reciben: `(req, res, filePath, staticConfig)`
+- Las acciones para `after_static_file_load` reciben: `(req, res, filePath, staticConfig, fileContent)`
+- El parámetro `acceptedArgs` define cuántos argumentos acepta tu callback (normalmente 4 para before y 5 para after)
+- El parámetro `priority` define el orden de ejecución (valores más bajos se ejecutan primero)
+- El hook se aplica tanto a archivos normales como a archivos índice (como `index.html`)
+
+## Consideraciones importantes:
+
+1. **Estado de la respuesta**: En `after_static_file_load`, el archivo ya ha sido leído pero aún no enviado, por lo que puedes modificar encabezados pero no el contenido sin una implementación adicional.
+
+2. **Rendimiento**: Ten cuidado al implementar lógica pesada en estos hooks ya que afectan el rendimiento de carga de archivos estáticos.
+
+3. **Seguridad**: Estos hooks son ideales para implementar controles de acceso, autenticación y auditoría en archivos estáticos.
+
+Estos hooks proporcionan una potente capacidad de personalización del comportamiento del framework al servir archivos estáticos, permitiendo implementar lógica de autenticación, auditoría, modificación de headers y más.

package/models/AdminUserModel.js

@@ -0,0 +1,132 @@
+/**
+ * Modelo de Usuario Administrador para BlackCoffee
+ * Gestiona la tabla admin_users en SQLite
+ */
+
+const path = require('path');
+const { ModelBase } = require('insitu-js');
+const crypto = require('crypto');
+
+class AdminUserModel extends ModelBase {
+  constructor(options = {}) {
+    super({
+      tableName: 'admin_users',
+      adapter: options.adapter || 'sqlite-pool',
+      fields: ['id', 'username', 'password_hash', 'email', 'role', 'active', 'created_at', 'updated_at', 'last_login']
+    });
+  }
+
+  /**
+   * Hash de contraseña usando crypto
+   */
+  static hashPassword(password) {
+    const salt = crypto.randomBytes(16).toString('hex');
+    const hash = crypto.pbkdf2Sync(password, salt, 1000, 64, 'sha512').toString('hex');
+    return `${salt}:${hash}`;
+  }
+
+  /**
+   * Verificar contraseña contra el hash almacenado
+   */
+  static verifyPassword(password, storedHash) {
+    try {
+      const [salt, hash] = storedHash.split(':');
+      const verifyHash = crypto.pbkdf2Sync(password, salt, 1000, 64, 'sha512').toString('hex');
+      return hash === verifyHash;
+    } catch (error) {
+      return false;
+    }
+  }
+
+  /**
+   * Buscar usuario por username
+   */
+  async findByUsername(username) {
+    if (!this.adapter) {
+      return null;
+    }
+
+    const selectSQL = `SELECT * FROM ${this.tableName} WHERE username = ?`;
+    const results = await this.adapter.query(selectSQL, [username]);
+    return results[0] || null;
+  }
+
+  /**
+   * Buscar usuario por username y verificar password
+   */
+  async findByCredentials(username, password) {
+    const user = await this.findByUsername(username);
+    
+    if (!user || !user.active) {
+      return null;
+    }
+
+    if (AdminUserModel.verifyPassword(password, user.password_hash)) {
+      // Actualizar último login usando query directa
+      try {
+        const updateSQL = `UPDATE ${this.tableName} SET last_login = ?, updated_at = ? WHERE id = ?`;
+        await this.adapter.query(updateSQL, [new Date().toISOString(), new Date().toISOString(), user.id]);
+      } catch (err) {
+        console.error('Error actualizando last_login:', err.message);
+      }
+      
+      // Devolver usuario sin el hash
+      const { password_hash, ...userWithoutPassword } = user;
+      return userWithoutPassword;
+    }
+
+    return null;
+  }
+
+  /**
+   * Buscar por ID
+   */
+  async findById(id) {
+    if (!this.adapter) {
+      return null;
+    }
+
+    const selectSQL = `SELECT * FROM ${this.tableName} WHERE id = ?`;
+    const results = await this.adapter.query(selectSQL, [id]);
+    return results[0] || null;
+  }
+
+  /**
+   * Crear usuario con password hasheado
+   */
+  async createWithPassword(userData) {
+    const { password, ...restData } = userData;
+    
+    const userWithHash = {
+      ...restData,
+      password_hash: AdminUserModel.hashPassword(password),
+      active: userData.active !== undefined ? userData.active : 1,
+      role: userData.role || 'admin',
+      created_at: new Date().toISOString(),
+      updated_at: new Date().toISOString()
+    };
+
+    const id = await this.create(userWithHash);
+    return { id, ...userWithHash };
+  }
+
+  /**
+   * Cambiar contraseña
+   */
+  async changePassword(userId, newPassword) {
+    const updateSQL = `UPDATE ${this.tableName} SET password_hash = ?, updated_at = ? WHERE id = ?`;
+    const hash = AdminUserModel.hashPassword(newPassword);
+    await this.adapter.query(updateSQL, [hash, new Date().toISOString(), userId]);
+    return true;
+  }
+
+  /**
+   * Verificar si existe el usuario
+   */
+  async usernameExists(username) {
+    const user = await this.findByUsername(username);
+    return !!user;
+  }
+}
+
+module.exports = AdminUserModel;

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "blackcoffee2",
+  "version": "2.1.0",
+  "description": "A app server built with Insitu Framework",
+  "main": "server.js",
+  "author": "Benjamin Sanchez Cardenas <bytedogssyndicate@gmail.com>",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://gitlab.com/bytedogssyndicate1/bc2"
+  },
+  "scripts": {
+    "start": "node server.js",
+    "admin": "node bin/adminclient",
+    "admin:connect": "node bin/adminclient",
+    "dev": "node --watch server.js",
+    "cli": "node bin/blackcoffee"
+  },
+  "bin": {
+    "blackcoffee": "./bin/blackcoffee"
+  },
+  "dependencies": {
+    "better-sqlite3": "^12.6.2",
+    "chokidar": "^5.0.0",
+    "gtk3-node": "^1.3.0",
+    "insitu-js": "^1.3.0"
+  },
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "keywords": [
+    "blackcoffee",
+    "insitu",
+    "application-server",
+    "app-server",
+    "https-server",
+    "rest-api",
+    "nodejs",
+    "web-server",
+    "backend",
+    "framework",
+    "microservices",
+    "api-server"
+  ]
+}

package/programatically/PRoutes.js

@@ -0,0 +1,89 @@
+/**
+ * Rutas registradas programáticamente en BlackCoffee v2.0.0
+ *
+ * Este archivo está reservado para rutas programáticas del núcleo.
+ * Los desarrolladores NO deben modificar este archivo.
+ *
+ * Para agregar rutas, usar:
+ *   - routes/*.json para rutas declarativas
+ *   - controllers/ para controladores
+ *   - apps/ para aplicaciones desplegadas
+ */
+
+const path = require('path');
+
+/**
+ * Registra las rutas programáticas del núcleo
+ * @param {Object} server - Instancia del servidor APIServer
+ */
+function PRoutes(server) {
+  console.log('📋 Registrando rutas del núcleo...\n');
+
+  // ============================================
+  // Rutas de Administración de Base de Datos
+  // ============================================
+  const DatabaseAdminController = require('../controllers/admin/DatabaseAdminController');
+
+  // API: Listar pools
+  server.addRoute('GET', '/api/admin/database/pools', (req, res) => {
+    DatabaseAdminController.getPools(req, res);
+  });
+
+  // API: Crear pool
+  server.addRoute('POST', '/api/admin/database/pools', (req, res) => {
+    DatabaseAdminController.createPool(req, res);
+  });
+
+  // API: Eliminar pool
+  server.addRoute('DELETE', '/api/admin/database/pools/:name', (req, res) => {
+    DatabaseAdminController.removePool(req, res);
+  });
+
+  // API: Conectar pool
+  server.addRoute('POST', '/api/admin/database/pools/:name/connect', (req, res) => {
+    DatabaseAdminController.connectPool(req, res);
+  });
+
+  // API: Desconectar pool
+  server.addRoute('POST', '/api/admin/database/pools/:name/disconnect', (req, res) => {
+    DatabaseAdminController.disconnectPool(req, res);
+  });
+
+  // UI: Página de Database Pools
+  server.addRoute('GET', '/admin/database', (req, res) => {
+    const fs = require('fs');
+    const dbPagePath = path.join(__dirname, '..', 'public', 'admin', 'database.html');
+    
+    if (fs.existsSync(dbPagePath)) {
+      const html = fs.readFileSync(dbPagePath, 'utf8');
+      res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+      res.end(html);
+    } else {
+      res.writeHead(404, { 'Content-Type': 'text/html; charset=utf-8' });
+      res.end('<h1>404 - Database Manager Page not found</h1>');
+    }
+  });
+
+  // UI: CSS para Database Pools
+  server.addRoute('GET', '-/admin/css/db-pools.css', {
+    static: {
+      dir: path.join(__dirname, '..', 'public', 'admin', 'css'),
+      cacheControl: 'public, max-age=31536000'
+    }
+  });
+
+  // UI: JS para Database Pools
+  server.addRoute('GET', '/admin/js/db-pools.js', {
+    static: {
+      dir: path.join(__dirname, '..', 'public', 'admin', 'js'),
+      cacheControl: 'public, max-age=31536000'
+    }
+  });
+
+  console.log('   ✅ Rutas de Database Admin registradas');
+  console.log('   ✅ PRoutes: listo para rutas del núcleo\n');
+}
+
+module.exports = {
+  PRoutes
+};