blackcoffee2 2.1.0

package/test-aplicacion.con-logisession/insitu-admin-client/README.md

@@ -0,0 +1,69 @@
+# Cliente CLI para Insitu Framework Administration Server
+
+Cliente de línea de comandos para interactuar con el servidor de administración de Insitu Framework. Permite reutilizar comandos y cuenta con autocompletado.
+
+## Características
+
+- **Autocompletado**: Presiona TAB para autocompletar comandos conocidos
+- **Historial de comandos**: Accede a comandos previamente utilizados
+- **Reutilización de comandos**: Reutiliza comandos por número o por texto
+- **Conservación de contexto**: Mantiene el historial entre sesiones
+
+## Instalación
+
+El cliente CLI está incluido en el framework Insitu y se puede ejecutar directamente:
+
+```bash
+node insitu-admin-client.js
+```
+
+O con parámetros específicos:
+
+```bash
+node insitu-admin-client.js --host 127.0.0.1 --port 9999
+```
+
+## Comandos del Cliente
+
+Además de los comandos del servidor de administración, el cliente CLI incluye comandos especiales:
+
+- `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 la ayuda del cliente
+
+## Uso
+
+1. Inicia el cliente:
+```bash
+node insitu-admin-client.js
+```
+
+2. El cliente se conectará automáticamente al servidor de administración en `localhost:9999`
+
+3. Usa los comandos estándar del servidor de administración:
+   - `stats` - Ver estadísticas generales
+   - `requests` - Ver estadísticas de solicitudes
+   - `endpoints` - Ver endpoints más accedidos
+   - `routes` - Ver rutas registradas
+   - `help` - Ver todos los comandos disponibles
+
+4. Usa los comandos especiales del cliente para mejorar la experiencia:
+   - `history` para ver comandos anteriores
+   - `re 3` para reutilizar el tercer comando del historial
+   - `re stats` para reutilizar el último comando que contenía "stats"
+
+## Atajos
+
+- Presiona `↑` y `↓` para navegar por el historial de comandos
+- Presiona `TAB` para autocompletar comandos
+- Presiona `Ctrl+C` para salir del cliente
+
+## Configuración
+
+Por defecto, el cliente intenta conectarse a `localhost:9999`. Puedes especificar un host y puerto diferente usando los argumentos `--host` y `--port`.
+
+## Archivo de Historial
+
+El cliente guarda el historial de comandos en `~/.insitu_admin_history` para conservarlo entre sesiones.

package/test-aplicacion.con-logisession/insitu-admin-client/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@insitu/admin-client",
+  "version": "1.0.0",
+  "description": "Cliente CLI para interactuar con el servidor de administración de Insitu Framework",
+  "main": "insitu-admin-client.js",
+  "bin": {
+    "insitu-admin": "./insitu-admin-client.js"
+  },
+  "scripts": {
+    "start": "node insitu-admin-client.js",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "insitu",
+    "admin",
+    "cli",
+    "client",
+    "framework"
+  ],
+  "author": "Insitu Framework Team",
+  "license": "Apache-2.0",
+  "dependencies": {}
+}

package/test-aplicacion.con-logisession/insitu-admin-client.js

@@ -0,0 +1,257 @@
+#!/usr/bin/env node
+
+/**
+ * Cliente CLI para interactuar con el servidor de administración de Insitu Framework
+ * Permite reutilizar comandos y tiene autocompletado
+ */
+
+const net = require('net');
+const readline = require('readline');
+const fs = require('fs');
+const path = require('path');
+
+// Configuración por defecto
+const DEFAULT_HOST = 'localhost';
+const DEFAULT_PORT = 9999;
+
+// Historial de comandos
+let commandHistory = [];
+const HISTORY_FILE = path.join(require('os').homedir(), '.insitu_admin_history');
+
+// Cargar historial de comandos si existe
+if (fs.existsSync(HISTORY_FILE)) {
+  try {
+    const historyData = fs.readFileSync(HISTORY_FILE, 'utf8');
+    commandHistory = JSON.parse(historyData);
+  } catch (error) {
+    console.error('Error al cargar el historial:', error.message);
+  }
+}
+
+// Comandos conocidos para autocompletado
+const knownCommands = [
+  'help',
+  'stats',
+  'statistics', 
+  'requests',
+  'endpoints',
+  'routes',
+  'active',
+  'version',
+  'status',
+  'cache',
+  'cache-stats',
+  'cache-clear',
+  'cache-info',
+  'sysinfo',
+  'system',
+  'resources',
+  'time',
+  'date',
+  'quit',
+  'exit'
+];
+
+// Función para guardar el historial
+function saveHistory() {
+  try {
+    fs.writeFileSync(HISTORY_FILE, JSON.stringify(commandHistory, null, 2));
+  } catch (error) {
+    console.error('Error al guardar el historial:', error.message);
+  }
+}
+
+// Función para autocompletar comandos
+function completer(line) {
+  const hits = knownCommands.filter(cmd => cmd.startsWith(line));
+  return [hits.length ? hits : knownCommands, line];
+}
+
+// Función para crear el cliente
+function createClient(host = DEFAULT_HOST, port = DEFAULT_PORT) {
+  const client = new net.Socket();
+  
+  // Conectar al servidor de administración
+  client.connect(port, host, () => {
+    console.log(`Conectado al servidor de administración en ${host}:${port}`);
+    console.log('Escribe "help" para ver los comandos disponibles o "quit" para salir\n');
+    
+    // Configurar readline con autocompletado
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+      completer: completer,
+      history: commandHistory
+    });
+    
+    // Mostrar historial de comandos recientes
+    if (commandHistory.length > 0) {
+      console.log(`Comandos recientes: ${commandHistory.slice(-5).join(', ')}\n`);
+    }
+    
+    // Función para manejar la entrada del usuario
+    function handleInput() {
+      rl.question('> ', (input) => {
+        const command = input.trim();
+        
+        if (command.toLowerCase() === 'quit' || command.toLowerCase() === 'exit') {
+          console.log('Desconectando del servidor...');
+          client.end();
+          rl.close();
+          saveHistory();
+          return;
+        }
+        
+        if (command.toLowerCase() === 'history') {
+          console.log('Historial de comandos:');
+          commandHistory.forEach((cmd, index) => {
+            console.log(`${index + 1}. ${cmd}`);
+          });
+          handleInput();
+          return;
+        }
+        
+        if (command.toLowerCase() === 'clear') {
+          console.clear();
+          handleInput();
+          return;
+        }
+        
+        if (command.toLowerCase() === 'help-cli') {
+          console.log('\n--- Comandos del Cliente CLI ---');
+          console.log('help-cli - Muestra esta ayuda');
+          console.log('history - Muestra el historial de comandos');
+          console.log('clear - Limpia la pantalla');
+          console.log('re <número> - Reutiliza el comando número n del historial');
+          console.log('re <texto> - Reutiliza el último comando que contiene el texto');
+          console.log('-----------------------------\n');
+          handleInput();
+          return;
+        }
+        
+        // Comando para reutilizar comandos del historial
+        if (command.toLowerCase().startsWith('re ')) {
+          const arg = command.substring(3).trim();
+          
+          if (/^\d+$/.test(arg)) {
+            // Reutilizar por número
+            const index = parseInt(arg) - 1;
+            if (index >= 0 && index < commandHistory.length) {
+              const reusedCmd = commandHistory[index];
+              console.log(`Reutilizando comando: ${reusedCmd}`);
+              client.write(reusedCmd + '\n');
+              if (!commandHistory.includes(reusedCmd)) {
+                commandHistory.push(reusedCmd);
+              }
+            } else {
+              console.log(`Número de comando inválido: ${arg}`);
+              handleInput();
+            }
+          } else {
+            // Reutilizar por texto
+            const matchingCmd = commandHistory.reverse().find(cmd => cmd.includes(arg));
+            commandHistory.reverse(); // Restaurar orden original
+            
+            if (matchingCmd) {
+              console.log(`Reutilizando comando: ${matchingCmd}`);
+              client.write(matchingCmd + '\n');
+            } else {
+              console.log(`No se encontró comando que contenga: ${arg}`);
+              handleInput();
+            }
+          }
+        } else if (command) {
+          // Enviar comando al servidor
+          client.write(command + '\n');
+          
+          // Agregar al historial si no está repetido
+          if (!commandHistory.includes(command)) {
+            commandHistory.push(command);
+            // Mantener solo los últimos 100 comandos
+            if (commandHistory.length > 100) {
+              commandHistory = commandHistory.slice(-100);
+            }
+          }
+        }
+        
+        handleInput();
+      });
+    }
+    
+    // Iniciar la interacción
+    handleInput();
+  });
+  
+  // Manejar datos recibidos del servidor
+  client.on('data', (data) => {
+    const output = data.toString();
+    process.stdout.write(output);
+    
+    // Si la salida termina con el prompt, significa que el comando terminó
+    if (output.endsWith('> ')) {
+      // No hacer nada, dejar que readline continúe
+    }
+  });
+  
+  // Manejar errores
+  client.on('error', (error) => {
+    console.error(`Error de conexión: ${error.message}`);
+    process.exit(1);
+  });
+  
+  // Manejar cierre de conexión
+  client.on('close', () => {
+    console.log('\nConexión cerrada');
+    process.exit(0);
+  });
+}
+
+// Mostrar ayuda
+function showHelp() {
+  console.log(`
+Cliente CLI para Insitu Framework Administration Server
+
+Uso: node insitu-admin-client.js [opciones]
+
+Opciones:
+  -h, --host HOST     Host del servidor (por defecto: ${DEFAULT_HOST})
+  -p, --port PORT     Puerto del servidor (por defecto: ${DEFAULT_PORT})
+  --help              Mostrar esta ayuda
+
+Comandos especiales del cliente:
+  history             Mostrar historial de comandos
+  clear               Limpiar la pantalla
+  re <número>         Reutilizar comando por número
+  re <texto>          Reutilizar último comando que contiene texto
+  help-cli            Mostrar ayuda del cliente
+
+Ejemplos:
+  node insitu-admin-client.js
+  node insitu-admin-client.js --host 127.0.0.1 --port 9999
+  `);
+}
+
+// Parsear argumentos
+const args = process.argv.slice(2);
+let host = DEFAULT_HOST;
+let port = DEFAULT_PORT;
+
+for (let i = 0; i < args.length; i++) {
+  if (args[i] === '--help' || args[i] === '-h') {
+    showHelp();
+    process.exit(0);
+  } else if (args[i] === '--host' || args[i] === '-h') {
+    host = args[++i];
+  } else if (args[i] === '--port' || args[i] === '-p') {
+    port = parseInt(args[++i]);
+  }
+}
+
+// Validar puerto
+if (isNaN(port) || port <= 0 || port > 65535) {
+  console.error(`Puerto inválido: ${port}`);
+  process.exit(1);
+}
+
+// Iniciar el cliente
+createClient(host, port);

package/test-aplicacion.con-logisession/models/ExampleModel.js

@@ -0,0 +1,88 @@
+const { ModelBase } = require('insitu-js');
+const { getSharedAdapter } = require('../utils/dbAdapter');
+
+class ProductModel extends ModelBase {
+  constructor(options = {}) {
+    // Obtener el adaptador centralizado
+    const adapter = getSharedAdapter();
+
+    super({
+      ...options,
+      tableName: options.tableName || 'products',
+      adapter: adapter
+    });
+  }
+
+  // Método para obtener todos los productos
+  async getAllProducts() {
+    try {
+      // En lugar de hacer una consulta real a la base de datos,
+      // devolvemos datos de ejemplo para demostrar el funcionamiento
+      return [
+        { id: 1, name: 'Laptop', description: 'Computadora portátil de alta gama', price: 1200, category: 'Electrónica' },
+        { id: 2, name: 'Teléfono', description: 'Smartphone con cámara de alta resolución', price: 800, category: 'Electrónica' },
+        { id: 3, name: 'Teclado', description: 'Teclado mecánico RGB', price: 100, category: 'Accesorios' },
+        { id: 4, name: 'Mouse', description: 'Mouse inalámbrico ergonómico', price: 50, category: 'Accesorios' },
+        { id: 5, name: 'Monitor', description: 'Monitor 4K de 27 pulgadas', price: 400, category: 'Electrónica' }
+      ];
+    } catch (error) {
+      throw new Error(`Error al obtener productos: ${error.message}`);
+    }
+  }
+
+  // Método para obtener un producto por ID
+  async getProductById(id) {
+    try {
+      const products = await this.getAllProducts();
+      return products.find(product => product.id == id) || null;
+    } catch (error) {
+      throw new Error(`Error al obtener producto por ID: ${error.message}`);
+    }
+  }
+
+  // Método para crear un nuevo producto
+  async createProduct(productData) {
+    try {
+      // Validar los datos del producto
+      if (!productData.name || !productData.description || !productData.price || !productData.category) {
+        throw new Error('Todos los campos son obligatorios: name, description, price, category');
+      }
+
+      // En una implementación real, aquí haríamos la inserción en la base de datos
+      // Por ahora, devolvemos un objeto simulando la creación
+      return {
+        id: Math.floor(Math.random() * 1000), // ID simulado
+        ...productData
+      };
+    } catch (error) {
+      throw new Error(`Error al crear producto: ${error.message}`);
+    }
+  }
+
+  // Método para actualizar un producto
+  async updateProduct(id, productData) {
+    try {
+      // En una implementación real, aquí haríamos la actualización en la base de datos
+      // Por ahora, devolvemos un objeto simulando la actualización
+      return {
+        id: parseInt(id),
+        ...productData
+      };
+    } catch (error) {
+      throw new Error(`Error al actualizar producto: ${error.message}`);
+    }
+  }
+
+  // Método para eliminar un producto
+  async deleteProduct(id) {
+    try {
+      // En una implementación real, aquí haríamos la eliminación en la base de datos
+      // Por ahora, simulamos la eliminación
+      return { success: true, message: `Producto con ID ${id} eliminado` };
+    } catch (error) {
+      throw new Error(`Error al eliminar producto: ${error.message}`);
+    }
+  }
+}
+
+module.exports = ProductModel;

package/test-aplicacion.con-logisession/models/QueueJobModel.js

@@ -0,0 +1,263 @@
+const { hooks } = require('insitu-js');
+
+class QueueJobModel {
+  constructor() {
+    // Cola de trabajos en memoria
+    this.jobs = new Map();
+    // Colas específicas para diferentes tipos de trabajos
+    this.queues = new Map();
+    // Trabajos en proceso
+    this.processingJobs = new Map();
+    // Trabajos completados
+    this.completedJobs = new Map();
+    // Trabajos fallidos
+    this.failedJobs = new Map();
+  }
+
+  // Crear un nuevo trabajo en la cola
+  async createJob(jobData) {
+    // Aplicar filtro para manipular los datos del trabajo antes de crearlo
+    const filteredJobData = await hooks.applyFiltersAsync('filter_queue_job_data', jobData);
+
+    // Disparar hook antes de crear el trabajo
+    await hooks.doActionAsync('queue_job_created_before', filteredJobData);
+
+    const jobId = this.generateId();
+    const job = {
+      id: jobId,
+      queue: filteredJobData.queue || 'default',
+      payload: filteredJobData.payload,
+      status: 'pending',
+      attempts: 0,
+      max_attempts: filteredJobData.max_attempts || 3,
+      created_at: new Date().toISOString(),
+      updated_at: new Date().toISOString(),
+      scheduled_for: filteredJobData.scheduled_for || new Date().toISOString(),
+      priority: filteredJobData.priority || 0,
+      result: null,
+      error: null
+    };
+
+    // Añadir el trabajo a la cola correspondiente
+    if (!this.queues.has(job.queue)) {
+      this.queues.set(job.queue, []);
+    }
+
+    // Disparar hook antes de ordenar la cola
+    await hooks.doActionAsync('queue_before_sort', job.queue, this.queues.get(job.queue));
+
+    // Añadir el trabajo a la cola, ordenado por prioridad
+    const queue = this.queues.get(job.queue);
+    queue.push(job);
+
+    // Ordenar por prioridad descendente y fecha de creación ascendente
+    queue.sort((a, b) => {
+      if (b.priority !== a.priority) {
+        return b.priority - a.priority;
+      }
+      return new Date(a.created_at) - new Date(b.created_at);
+    });
+
+    // Disparar hook después de ordenar la cola
+    await hooks.doActionAsync('queue_after_sort', job.queue, queue);
+
+    // Registrar el trabajo en el mapa general
+    this.jobs.set(jobId, job);
+
+    // Disparar hook después de crear el trabajo
+    await hooks.doActionAsync('queue_job_created', job);
+
+    return job;
+  }
+
+  // Obtener un trabajo pendiente de una cola específica
+  async getNextPendingJob(queue = 'default') {
+    // Disparar hook antes de obtener un trabajo pendiente
+    await hooks.doActionAsync('queue_get_pending_job_before', queue);
+
+    if (!this.queues.has(queue)) {
+      // Disparar hook si la cola no existe
+      await hooks.doActionAsync('queue_not_found', queue);
+      return null;
+    }
+
+    const queueArray = this.queues.get(queue);
+    const now = new Date();
+
+    // Buscar el siguiente trabajo pendiente programado para ahora o antes
+    for (let i = 0; i < queueArray.length; i++) {
+      const job = queueArray[i];
+      if (job.status === 'pending' && new Date(job.scheduled_for) <= now) {
+        // Disparar hook cuando se encuentra un trabajo pendiente
+        await hooks.doActionAsync('queue_pending_job_found', job, queue);
+        return job;
+      }
+    }
+
+    // Disparar hook si no se encuentra trabajo pendiente
+    await hooks.doActionAsync('queue_no_pending_job', queue);
+
+    return null;
+  }
+
+  // Marcar un trabajo como en proceso
+  async markJobAsProcessing(jobId) {
+    const job = this.jobs.get(jobId);
+    if (job) {
+      // Disparar hook antes de marcar como en proceso
+      await hooks.doActionAsync('queue_job_processing_before', job);
+
+      job.status = 'processing';
+      job.updated_at = new Date().toISOString();
+      this.processingJobs.set(jobId, job);
+
+      // Remover de la cola pendiente
+      const queue = this.queues.get(job.queue);
+      if (queue) {
+        const index = queue.findIndex(j => j.id === jobId);
+        if (index !== -1) {
+          queue.splice(index, 1);
+        }
+      }
+
+      // Disparar hook después de marcar como en proceso
+      await hooks.doActionAsync('queue_job_processing', job);
+    }
+  }
+
+  // Marcar un trabajo como completado
+  async markJobAsCompleted(jobId, result = null) {
+    const job = this.jobs.get(jobId);
+    if (job) {
+      // Aplicar filtro para manipular el resultado antes de guardarlo
+      const filteredResult = await hooks.applyFiltersAsync('filter_queue_job_result', result, job);
+
+      // Disparar hook antes de marcar como completado
+      await hooks.doActionAsync('queue_job_completed_before', job, filteredResult);
+
+      job.status = 'completed';
+      job.result = filteredResult;
+      job.updated_at = new Date().toISOString();
+
+      // Mover de processing a completed
+      this.processingJobs.delete(jobId);
+      this.completedJobs.set(jobId, job);
+
+      // Disparar hook después de marcar como completado
+      await hooks.doActionAsync('queue_job_completed', job);
+    }
+  }
+
+  // Marcar un trabajo como fallido
+  async markJobAsFailed(jobId, error = null) {
+    const job = this.jobs.get(jobId);
+    if (job) {
+      // Aplicar filtro para manipular el error antes de guardarlo
+      const filteredError = await hooks.applyFiltersAsync('filter_queue_job_error', error, job);
+
+      // Disparar hook antes de marcar como fallido
+      await hooks.doActionAsync('queue_job_failed_before', job, filteredError);
+
+      job.status = 'failed';
+      job.error = filteredError;
+      job.attempts += 1;
+      job.updated_at = new Date().toISOString();
+
+      // Mover de processing a failed
+      this.processingJobs.delete(jobId);
+      this.failedJobs.set(jobId, job);
+
+      // Disparar hook después de marcar como fallido
+      await hooks.doActionAsync('queue_job_failed', job, filteredError);
+    }
+  }
+
+  // Verificar si un trabajo debe reintetntarse
+  async shouldRetryJob(jobId, error = null) {
+    const job = this.jobs.get(jobId);
+    if (job) {
+      // Disparar hook para tomar decisiones personalizadas sobre si reintentar un trabajo
+      const customRetryDecision = await hooks.applyFiltersAsync('queue_job_should_retry', null, job, error);
+
+      if (customRetryDecision !== null) {
+        return customRetryDecision;
+      }
+
+      // No reintentar si es un error de seguridad
+      if (error && typeof error === 'string' && error.includes('SECURITY_ERROR')) {
+        return false;
+      }
+      return job.attempts < job.max_attempts;
+    }
+    return false;
+  }
+
+  // Obtener el estado de un trabajo
+  async getJobStatus(jobId) {
+    // Disparar hook antes de obtener el estado del trabajo
+    await hooks.doActionAsync('queue_get_job_status_before', jobId);
+
+    let job = null;
+
+    if (this.jobs.has(jobId)) {
+      job = this.jobs.get(jobId);
+    } else if (this.processingJobs.has(jobId)) {
+      job = this.processingJobs.get(jobId);
+    } else if (this.completedJobs.has(jobId)) {
+      job = this.completedJobs.get(jobId);
+    } else if (this.failedJobs.has(jobId)) {
+      job = this.failedJobs.get(jobId);
+    }
+
+    // Disparar hook después de obtener el estado del trabajo
+    await hooks.doActionAsync('queue_get_job_status_after', job, jobId);
+
+    return job;
+  }
+
+  // Generar un ID único para el trabajo
+  generateId() {
+    return Date.now().toString(36) + Math.random().toString(36).substr(2, 5);
+  }
+
+  // Obtener trabajos por estado
+  getJobsByStatus(status) {
+    // Disparar hook antes de obtener trabajos por estado
+    hooks.doAction('queue_get_jobs_by_status_before', status);
+
+    let jobs = [];
+
+    switch(status) {
+      case 'pending':
+        // Obtener todos los trabajos pendientes de todas las colas
+        const pendingJobs = [];
+        for (const queue of this.queues.values()) {
+          pendingJobs.push(...queue.filter(job => job.status === 'pending'));
+        }
+        jobs = pendingJobs;
+        break;
+      case 'processing':
+        jobs = Array.from(this.processingJobs.values());
+        break;
+      case 'completed':
+        jobs = Array.from(this.completedJobs.values());
+        break;
+      case 'failed':
+        jobs = Array.from(this.failedJobs.values());
+        break;
+      default:
+        jobs = [];
+        break;
+    }
+
+    // Disparar hook después de obtener trabajos por estado
+    hooks.doAction('queue_get_jobs_by_status_after', jobs, status);
+
+    return jobs;
+  }
+}
+
+// Instancia global del modelo de cola
+const globalQueueJobModel = new QueueJobModel();
+
+module.exports = globalQueueJobModel;