@arela/uploader 0.2.13 → 1.0.0

package/src/services/SmartWatchDatabaseService.js

@@ -0,0 +1,527 @@
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+import logger from './LoggingService.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+/**
+ * SmartWatchDatabaseService
+ * Specialized database service for Smart Watch Queue management
+ * Handles file state transitions, batch processing, and progress tracking
+ */
+export class SmartWatchDatabaseService {
+  #databaseService;
+
+  /**
+   * Initialize with a DatabaseService instance
+   * @param {DatabaseService} databaseService - The main database service
+   */
+  constructor(databaseService) {
+    if (!databaseService) {
+      throw new Error('DatabaseService instance is required');
+    }
+    this.#databaseService = databaseService;
+  }
+
+  /**
+   * Inserta un archivo a la tabla uploader con estado PENDING o READY_TO_UPLOAD
+   * @param {string} filePath - Ruta del archivo
+   * @param {Object} options - Opciones { processingStatus, dependsOnPath, size, extension }
+   * @returns {Promise<Object>} Archivo insertado
+   */
+  async insertFileToUploader(filePath, options = {}) {
+    const {
+      processingStatus = 'PENDING',
+      dependsOnPath = null,
+      documentType = null,
+      size = null,
+      fileExtension = null,
+    } = options;
+
+    return this.#databaseService.queryWithRetry(async () => {
+      const supabase = await this.#databaseService.getSupabaseClient();
+      const fileName = path.basename(filePath);
+
+      const fileData = {
+        name: fileName,
+        original_path: filePath,
+        filename: fileName,
+        file_extension:
+          fileExtension ||
+          path.extname(fileName).toLowerCase().replace('.', ''),
+        size: size || 0,
+        document_type: documentType,
+        processing_status: processingStatus,
+        depends_on_path: dependsOnPath,
+        created_at: new Date().toISOString(),
+        updated_at: new Date().toISOString(),
+        upload_attempts: 0,
+        status: 'pending',
+      };
+
+      const { data, error } = await supabase
+        .from('uploader')
+        .insert([fileData])
+        .select();
+
+      // Handle duplicate key errors gracefully
+      if (error) {
+        if (error.message.includes('duplicate key')) {
+          logger.debug(`⏭️  File already exists: ${fileName}`);
+          // Return existing file data instead of throwing
+          return { file_path: filePath, file_name: fileName };
+        }
+        throw new Error(`Error inserting file: ${error.message}`);
+      }
+
+      logger.debug(
+        `✅ File inserted: ${fileName} (status: ${processingStatus})`,
+      );
+      return data?.[0];
+    }, 'Insert file to uploader');
+  }
+
+  /**
+   * Obtiene archivos PENDING en un directorio específico
+   * @param {string} dirPath - Ruta del directorio
+   * @returns {Promise<Array>} Archivos pendientes
+   */
+  async getPendingFilesInDirectory(dirPath) {
+    return this.#databaseService.queryWithRetry(async () => {
+      const supabase = await this.#databaseService.getSupabaseClient();
+
+      const { data, error } = await supabase
+        .from('uploader')
+        .select('*')
+        .eq('depends_on_path', dirPath)
+        .eq('processing_status', 'PENDING')
+        .order('created_at', { ascending: true });
+
+      if (error) {
+        throw new Error(`Error getting pending files: ${error.message}`);
+      }
+
+      return data || [];
+    }, 'Get pending files in directory');
+  }
+
+  /**
+   * Obtiene archivos con ciertos status
+   * @param {Array} statuses - Array de status a buscar
+   * @param {number} limit - Límite de resultados
+   * @returns {Promise<Array>} Archivos con los status especificados
+   */
+  async getFilesWithStatus(statuses, limit = 10) {
+    return this.#databaseService.queryWithRetry(async () => {
+      const supabase = await this.#databaseService.getSupabaseClient();
+
+      let query = supabase
+        .from('uploader')
+        .select('*')
+        .in('processing_status', statuses)
+        .order('created_at', { ascending: true })
+        .limit(limit);
+
+      const { data, error } = await query;
+
+      if (error) {
+        throw new Error(`Error getting files with status: ${error.message}`);
+      }
+
+      return data || [];
+    }, 'Get files with status');
+  }
+
+  /**
+   * Actualiza el status de un archivo
+   * @param {string} filePath - Ruta original del archivo
+   * @param {Object} updates - Actualizaciones a realizar
+   * @returns {Promise<Object>} Archivo actualizado
+   */
+  async updateFileStatus(filePath, updates) {
+    return this.#databaseService.queryWithRetry(async () => {
+      const supabase = await this.#databaseService.getSupabaseClient();
+
+      const updateData = {
+        ...updates,
+        updated_at: new Date().toISOString(),
+      };
+
+      const { data, error } = await supabase
+        .from('uploader')
+        .update(updateData)
+        .eq('original_path', filePath)
+        .select();
+
+      if (error) {
+        throw new Error(`Error updating file status: ${error.message}`);
+      }
+
+      logger.debug(
+        `✅ File status updated: ${path.basename(filePath)} -> ${updates.processing_status}`,
+      );
+      return data?.[0];
+    }, 'Update file status');
+  }
+
+  /**
+   * Marca un directorio como "tiene pedimento detectado"
+   * @param {string} dirPath - Ruta del directorio
+   * @param {string} pedimentoPath - Ruta del archivo pedimento
+   * @returns {Promise<Object>} Archivo pedimento actualizado
+   */
+  async markPedimentoDetected(dirPath, pedimentoPath) {
+    return this.#databaseService.queryWithRetry(async () => {
+      const supabase = await this.#databaseService.getSupabaseClient();
+
+      const { data, error } = await supabase
+        .from('uploader')
+        .update({
+          pedimento_detected_at: new Date().toISOString(),
+          processing_status: 'READY_TO_UPLOAD',
+          updated_at: new Date().toISOString(),
+        })
+        .eq('original_path', pedimentoPath)
+        .select();
+
+      if (error) {
+        throw new Error(`Error marking pedimento detected: ${error.message}`);
+      }
+
+      logger.info(
+        `✅ Pedimento marked as detected: ${path.basename(pedimentoPath)}`,
+      );
+
+      // Ahora marcar archivos pendientes como READY_TO_UPLOAD
+      const pendingFiles = await this.getPendingFilesInDirectory(dirPath);
+
+      if (pendingFiles.length > 0) {
+        logger.info(
+          `🔄 Marking ${pendingFiles.length} pending files as READY_TO_UPLOAD`,
+        );
+
+        for (const file of pendingFiles) {
+          await this.updateFileStatus(file.original_path, {
+            processing_status: 'READY_TO_UPLOAD',
+            pedimento_detected_at: new Date().toISOString(),
+          });
+        }
+      }
+
+      return data?.[0];
+    }, 'Mark pedimento detected');
+  }
+
+  /**
+   * Obtiene archivos que llevan esperando más del máximo
+   * @param {number} maxWaitTimeSeconds - Tiempo máximo en segundos
+   * @returns {Promise<Array>} Archivos expirados
+   */
+  async getExpiredWaitingFiles(maxWaitTimeSeconds) {
+    return this.#databaseService.queryWithRetry(async () => {
+      const supabase = await this.#databaseService.getSupabaseClient();
+      const cutoffTime = new Date(
+        Date.now() - maxWaitTimeSeconds * 1000,
+      ).toISOString();
+
+      const { data, error } = await supabase
+        .from('uploader')
+        .select('*')
+        .eq('processing_status', 'PENDING')
+        .lt('created_at', cutoffTime)
+        .order('created_at', { ascending: true });
+
+      if (error) {
+        throw new Error(
+          `Error getting expired waiting files: ${error.message}`,
+        );
+      }
+
+      return data || [];
+    }, 'Get expired waiting files');
+  }
+
+  /**
+   * Obtiene estadísticas de procesamiento
+   * @returns {Promise<Object>} Estadísticas por status
+   */
+  async getProcessingStats() {
+    return this.#databaseService.queryWithRetry(async () => {
+      const supabase = await this.#databaseService.getSupabaseClient();
+      const statuses = [
+        'PENDING',
+        'READY_TO_UPLOAD',
+        'PROCESSING',
+        'UPLOADED',
+        'FAILED',
+      ];
+
+      const stats = {
+        pending: 0,
+        readyToUpload: 0,
+        processing: 0,
+        uploaded: 0,
+        failed: 0,
+        total: 0,
+      };
+
+      for (const status of statuses) {
+        const { count, error } = await supabase
+          .from('uploader')
+          .select('*', { count: 'exact', head: true })
+          .eq('processing_status', status);
+
+        if (!error && count !== null) {
+          stats.total += count;
+          switch (status) {
+            case 'PENDING':
+              stats.pending = count;
+              break;
+            case 'READY_TO_UPLOAD':
+              stats.readyToUpload = count;
+              break;
+            case 'PROCESSING':
+              stats.processing = count;
+              break;
+            case 'UPLOADED':
+              stats.uploaded = count;
+              break;
+            case 'FAILED':
+              stats.failed = count;
+              break;
+          }
+        }
+      }
+
+      return stats;
+    }, 'Get processing stats');
+  }
+
+  /**
+   * Obtiene archivos fallidos listos para reintentar
+   * @param {number} maxAttempts - Máximo número de intentos
+   * @returns {Promise<Array>} Archivos fallidos para reintentar
+   */
+  async getFailedFilesForRetry(maxAttempts = 3) {
+    return this.#databaseService.queryWithRetry(async () => {
+      const supabase = await this.#databaseService.getSupabaseClient();
+
+      const { data, error } = await supabase
+        .from('uploader')
+        .select('*')
+        .eq('processing_status', 'FAILED')
+        .lt('upload_attempts', maxAttempts)
+        .order('upload_attempts', { ascending: true })
+        .order('updated_at', { ascending: true });
+
+      if (error) {
+        throw new Error(
+          `Error getting failed files for retry: ${error.message}`,
+        );
+      }
+
+      return data || [];
+    }, 'Get failed files for retry');
+  }
+
+  /**
+   * Reinicia un archivo fallido
+   * @param {string} filePath - Ruta del archivo
+   * @returns {Promise<Object>} Archivo reiniciado
+   */
+  async retryFile(filePath) {
+    return this.#databaseService.queryWithRetry(async () => {
+      return this.updateFileStatus(filePath, {
+        processing_status: 'READY_TO_UPLOAD',
+        upload_attempts: 0,
+        last_error: null,
+      });
+    }, `Retry file: ${filePath}`);
+  }
+
+  /**
+   * Reinicia múltiples archivos fallidos
+   * @param {number} limit - Cantidad máxima a reintentar
+   * @param {number} maxAttempts - Máximo número de intentos permitidos
+   * @returns {Promise<Object>} Resultado del reintento
+   */
+  async retryFailedFiles(limit = 10, maxAttempts = 3) {
+    return this.#databaseService.queryWithRetry(async () => {
+      const failedFiles = await this.getFailedFilesForRetry(maxAttempts);
+      const toRetry = failedFiles.slice(0, limit);
+
+      const results = {
+        retried: 0,
+        skipped: 0,
+        files: [],
+      };
+
+      for (const file of toRetry) {
+        try {
+          const updated = await this.retryFile(file.original_path);
+          results.retried++;
+          results.files.push(updated);
+        } catch (error) {
+          logger.error(
+            `Error retrying file ${file.filename}: ${error.message}`,
+          );
+          results.skipped++;
+        }
+      }
+
+      logger.info(
+        `🔄 Retried ${results.retried} files, skipped ${results.skipped}`,
+      );
+      return results;
+    }, 'Retry failed files');
+  }
+
+  /**
+   * Obtiene progreso general del procesamiento
+   * @returns {Promise<Object>} Progreso con ETA
+   */
+  async getOverallProgress() {
+    return this.#databaseService.queryWithRetry(async () => {
+      const stats = await this.getProcessingStats();
+
+      const totalFiles =
+        stats.pending +
+        stats.readyToUpload +
+        stats.processing +
+        stats.uploaded +
+        stats.failed;
+      const processedFiles = stats.uploaded;
+      const failedFiles = stats.failed;
+      const pendingFiles =
+        stats.pending + stats.readyToUpload + stats.processing;
+
+      // Obtener archivos recientemente subidos para calcular promedio
+      const supabase = await this.#databaseService.getSupabaseClient();
+      const { data: recentUploaded } = await supabase
+        .from('uploader')
+        .select('*')
+        .eq('processing_status', 'UPLOADED')
+        .order('updated_at', { ascending: false })
+        .limit(100);
+
+      let avgProcessingTimeMs = 0;
+      if (recentUploaded && recentUploaded.length > 0) {
+        const totalTime = recentUploaded.reduce((sum, file) => {
+          if (file.created_at && file.updated_at) {
+            return (
+              sum +
+              (new Date(file.updated_at).getTime() -
+                new Date(file.created_at).getTime())
+            );
+          }
+          return sum;
+        }, 0);
+        avgProcessingTimeMs = totalTime / recentUploaded.length;
+      }
+
+      // Estimar tiempo restante
+      const remainingTime = pendingFiles * avgProcessingTimeMs;
+      const hours = Math.floor(remainingTime / (1000 * 60 * 60));
+      const minutes = Math.floor(
+        (remainingTime % (1000 * 60 * 60)) / (1000 * 60),
+      );
+      const estimatedTimeRemaining = `${hours}h ${minutes}m`;
+
+      const percentComplete =
+        totalFiles > 0 ? Math.round((processedFiles / totalFiles) * 100) : 0;
+
+      return {
+        totalFiles,
+        processedFiles,
+        failedFiles,
+        pendingFiles,
+        percentComplete,
+        estimatedTimeRemaining,
+        avgProcessingTimeMs: Math.round(avgProcessingTimeMs),
+      };
+    }, 'Get overall progress');
+  }
+
+  /**
+   * Obtiene detalles de un archivo específico
+   * @param {string} filePath - Ruta del archivo
+   * @returns {Promise<Object>} Detalles del archivo
+   */
+  async getFileDetails(filePath) {
+    return this.#databaseService.queryWithRetry(async () => {
+      const supabase = await this.#databaseService.getSupabaseClient();
+
+      const { data, error } = await supabase
+        .from('uploader')
+        .select('*')
+        .eq('original_path', filePath)
+        .single();
+
+      if (error) {
+        throw new Error(`File not found: ${filePath}`);
+      }
+
+      return {
+        ...data,
+        timeInQueue: data.created_at
+          ? `${Math.round((Date.now() - new Date(data.created_at).getTime()) / 1000)}s`
+          : null,
+        attempts: data.upload_attempts,
+        hasError: !!data.last_error,
+      };
+    }, `Get file details: ${filePath}`);
+  }
+
+  /**
+   * Busca archivos por múltiples criterios
+   * @param {Object} filters - Filtros de búsqueda
+   * @returns {Promise<Array>} Archivos que coinciden
+   */
+  async searchFiles(filters = {}) {
+    return this.#databaseService.queryWithRetry(async () => {
+      const { status, rfc, year, dirPath, numPedimento, limit = 50 } = filters;
+
+      const supabase = await this.#databaseService.getSupabaseClient();
+      let query = supabase.from('uploader').select('*');
+
+      if (status) {
+        query = query.eq('processing_status', status);
+      }
+
+      if (rfc) {
+        query = query.eq('rfc', rfc);
+      }
+
+      if (year) {
+        query = query.eq('year', year);
+      }
+
+      if (dirPath) {
+        query = query.eq('depends_on_path', dirPath);
+      }
+
+      if (numPedimento) {
+        query = query.ilike('num_pedimento', `%${numPedimento}%`);
+      }
+
+      query = query.order('created_at', { ascending: false }).limit(limit);
+
+      const { data, error } = await query;
+
+      if (error) {
+        throw new Error(`Error searching files: ${error.message}`);
+      }
+
+      return data || [];
+    }, 'Search files');
+  }
+}
+
+// Export singleton factory function
+export function createSmartWatchDatabaseService(databaseService) {
+  return new SmartWatchDatabaseService(databaseService);
+}
+
+export default SmartWatchDatabaseService;