@arela/uploader 0.2.5 → 0.2.6

package/src/services/DatabaseService.js

@@ -25,6 +25,51 @@ export class DatabaseService {
     return await supabaseService.getClient();
   }
 
+  /**
+   * Execute database query with retry logic and exponential backoff
+   * @private
+   * @param {Function} queryFn - Query function to execute
+   * @param {string} operation - Description of the operation for logging
+   * @param {number} maxRetries - Maximum number of retry attempts (default: 3)
+   * @returns {Promise<Object>} Query result
+   */
+  async #queryWithRetry(queryFn, operation, maxRetries = 3) {
+    let lastError;
+
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+      try {
+        const result = await queryFn();
+        if (attempt > 1) {
+          logger.info(`${operation} succeeded on attempt ${attempt}`);
+        }
+        return result;
+      } catch (error) {
+        lastError = error;
+
+        // Check if it's a timeout or connection error
+        const isRetriableError =
+          error.message?.includes('timeout') ||
+          error.message?.includes('canceling statement') ||
+          error.message?.includes('connection') ||
+          error.code === 'PGRST301'; // PostgREST timeout
+
+        if (!isRetriableError || attempt === maxRetries) {
+          throw error;
+        }
+
+        const backoffDelay = Math.min(1000 * Math.pow(2, attempt - 1), 30000); // Cap at 30 seconds
+        logger.warn(
+          `${operation} failed on attempt ${attempt}/${maxRetries}: ${error.message}`,
+        );
+        logger.info(`Retrying in ${backoffDelay}ms...`);
+
+        await new Promise((resolve) => setTimeout(resolve, backoffDelay));
+      }
+    }
+
+    throw lastError;
+  }
+
   /**
    * Insert file stats with document detection into uploader table
    * @param {Array} files - Array of file objects
@@ -47,7 +92,9 @@ export class DatabaseService {
         .limit(1);
 
       if (checkError) {
-        logger.error(`Error checking for existing record: ${checkError.message}`);
+        logger.error(
+          `Error checking for existing record: ${checkError.message}`,
+        );
         continue;
       }
 
@@ -113,7 +160,9 @@ export class DatabaseService {
       return [];
     }
 
-    logger.info(`Inserting ${records.length} new records into uploader table...`);
+    logger.info(
+      `Inserting ${records.length} new records into uploader table...`,
+    );
 
     const { data, error } = await supabase
       .from('uploader')
@@ -174,7 +223,9 @@ export class DatabaseService {
       return { totalInserted: 0, totalSkipped: 0, totalProcessed: 0 };
     }
 
-    logger.info(`Processing ${allRecords.length} file stats in batches of ${batchSize}...`);
+    logger.info(
+      `Processing ${allRecords.length} file stats in batches of ${batchSize}...`,
+    );
 
     let totalInserted = 0;
     let totalUpdated = 0;
@@ -184,20 +235,28 @@ export class DatabaseService {
 
       try {
         // Check which records already exist
-        const originalPaths = batch.map(r => r.original_path);
+        const originalPaths = batch.map((r) => r.original_path);
         const { data: existingRecords, error: checkError } = await supabase
           .from('uploader')
           .select('original_path')
           .in('original_path', originalPaths);
 
         if (checkError) {
-          logger.error(`Error checking existing records: ${checkError.message}`);
+          logger.error(
+            `Error checking existing records: ${checkError.message}`,
+          );
           continue;
         }
 
-        const existingPaths = new Set(existingRecords?.map(r => r.original_path) || []);
-        const newRecords = batch.filter(r => !existingPaths.has(r.original_path));
-        const updateRecords = batch.filter(r => existingPaths.has(r.original_path));
+        const existingPaths = new Set(
+          existingRecords?.map((r) => r.original_path) || [],
+        );
+        const newRecords = batch.filter(
+          (r) => !existingPaths.has(r.original_path),
+        );
+        const updateRecords = batch.filter((r) =>
+          existingPaths.has(r.original_path),
+        );
 
         logger.info(
           `Batch ${Math.floor(i / batchSize) + 1}: ${newRecords.length} new, ${updateRecords.length} updates`,
@@ -238,7 +297,6 @@ export class DatabaseService {
           totalUpdated += batchUpdated;
           logger.info(`Updated ${batchUpdated} existing records`);
         }
-
       } catch (error) {
         logger.error(
           `Unexpected error in batch ${Math.floor(i / batchSize) + 1}: ${error.message}`,
@@ -264,11 +322,14 @@ export class DatabaseService {
    */
   async detectPedimentosInDatabase(options = {}) {
     const supabase = await this.#getSupabaseClient();
-    
-    logger.info('Phase 2: Starting PDF detection for pedimento-simplificado documents...');
-    
+
+    logger.info(
+      'Phase 2: Starting PDF detection for pedimento-simplificado documents...',
+    );
+
     const processingBatchSize = parseInt(options.batchSize) || 10;
-    const queryBatchSize = 1000;
+    // Reduced query batch size to avoid timeouts
+    const queryBatchSize = 500; // Reduced from 1000 to 500
 
     let totalDetected = 0;
     let totalProcessed = 0;
@@ -276,135 +337,168 @@ export class DatabaseService {
     let offset = 0;
     let chunkNumber = 1;
 
-    logger.info('Processing PDF files in chunks of 1000 records...');
+    logger.info(
+      `Processing PDF files in chunks of ${queryBatchSize} records...`,
+    );
 
     while (true) {
       logger.info(
         `Fetching chunk ${chunkNumber} (records ${offset + 1} to ${offset + queryBatchSize})...`,
       );
 
-      const { data: pdfRecords, error: queryError } = await supabase
-        .from('uploader')
-        .select('id, original_path, filename, file_extension, status')
-        .eq('status', 'fs-stats')
-        .eq('file_extension', 'pdf')
-        .ilike('filename', '%simp%')
-        .range(offset, offset + queryBatchSize - 1);
+      try {
+        // Split the query to make it more efficient with retry logic
+        const { data: pdfRecords, error: queryError } =
+          await this.#queryWithRetry(async () => {
+            return await supabase
+              .from('uploader')
+              .select('id, original_path, filename, file_extension, status')
+              .eq('status', 'fs-stats')
+              .eq('file_extension', 'pdf')
+              .ilike('filename', '%simp%')
+              .range(offset, offset + queryBatchSize - 1)
+              .order('id'); // Add explicit ordering for consistent pagination
+          }, `fetch PDF records chunk ${chunkNumber}`);
 
-      if (queryError) {
-        throw new Error(
-          `Failed to fetch PDF records chunk ${chunkNumber}: ${queryError.message}`,
-        );
-      }
+        if (queryError) {
+          throw new Error(
+            `Failed to fetch PDF records chunk ${chunkNumber}: ${queryError.message}`,
+          );
+        }
 
-      if (!pdfRecords || pdfRecords.length === 0) {
-        logger.info('No more PDF files found. Processing completed.');
-        break;
-      }
+        if (!pdfRecords || pdfRecords.length === 0) {
+          logger.info('No more PDF files found. Processing completed.');
+          break;
+        }
 
-      logger.info(`Processing chunk ${chunkNumber}: ${pdfRecords.length} PDF records`);
+        logger.info(
+          `Processing chunk ${chunkNumber}: ${pdfRecords.length} PDF records`,
+        );
 
-      let chunkDetected = 0;
-      let chunkProcessed = 0;
-      let chunkErrors = 0;
+        let chunkDetected = 0;
+        let chunkProcessed = 0;
+        let chunkErrors = 0;
+
+        // Process files in smaller batches
+        for (let i = 0; i < pdfRecords.length; i += processingBatchSize) {
+          const batch = pdfRecords.slice(i, i + processingBatchSize);
+          const updatePromises = [];
+
+          for (const record of batch) {
+            try {
+              if (!fs.existsSync(record.original_path)) {
+                logger.warn(
+                  `File not found: ${record.filename} at ${record.original_path}`,
+                );
+                updatePromises.push(
+                  supabase
+                    .from('uploader')
+                    .update({
+                      status: 'file-not-found',
+                      message: 'File no longer exists at original path',
+                    })
+                    .eq('id', record.id),
+                );
+                chunkErrors++;
+                totalErrors++;
+                continue;
+              }
 
-      // Process files in smaller batches
-      for (let i = 0; i < pdfRecords.length; i += processingBatchSize) {
-        const batch = pdfRecords.slice(i, i + processingBatchSize);
-        const updatePromises = [];
+              const detection = await this.detectionService.detectFile(
+                record.original_path,
+              );
+              chunkProcessed++;
+              totalProcessed++;
+
+              const updateData = {
+                status: detection.detectedType ? 'detected' : 'not-detected',
+                document_type: detection.detectedType,
+                num_pedimento: detection.detectedPedimento,
+                arela_path: detection.arelaPath,
+                message: detection.error || null,
+              };
+
+              if (detection.fields) {
+                const rfcField = detection.fields.find(
+                  (f) => f.name === 'rfc' && f.found,
+                );
+                if (rfcField) {
+                  updateData.rfc = rfcField.value;
+                }
+              }
+
+              if (detection.detectedType) {
+                chunkDetected++;
+                totalDetected++;
+                logger.success(
+                  `Detected: ${record.filename} -> ${detection.detectedType} | Pedimento: ${detection.detectedPedimento || 'N/A'} | RFC: ${detection.fields?.rfc || 'N/A'}`,
+                );
+              } else {
+                logger.info(
+                  `Not detected: ${record.filename} - No pedimento-simplificado pattern found`,
+                );
+              }
 
-        for (const record of batch) {
-          try {
-            if (!fs.existsSync(record.original_path)) {
-              logger.warn(`File not found: ${record.filename} at ${record.original_path}`);
               updatePromises.push(
                 supabase
                   .from('uploader')
-                  .update({
-                    status: 'file-not-found',
-                    message: 'File no longer exists at original path',
-                  })
+                  .update(updateData)
                   .eq('id', record.id),
               );
+            } catch (error) {
+              logger.error(
+                `Error detecting ${record.filename}: ${error.message}`,
+              );
               chunkErrors++;
               totalErrors++;
-              continue;
-            }
 
-            const detection = await this.detectionService.detectFile(record.original_path);
-            chunkProcessed++;
-            totalProcessed++;
-
-            const updateData = {
-              status: detection.detectedType ? 'detected' : 'not-detected',
-              document_type: detection.detectedType,
-              num_pedimento: detection.detectedPedimento,
-              arela_path: detection.arelaPath,
-              message: detection.error || null,
-            };
-
-            if (detection.fields) {
-              const rfcField = detection.fields.find(
-                (f) => f.name === 'rfc' && f.found,
-              );
-              if (rfcField) {
-                updateData.rfc = rfcField.value;
-              }
-            }
-
-            if (detection.detectedType) {
-              chunkDetected++;
-              totalDetected++;
-              logger.success(
-                `Detected: ${record.filename} -> ${detection.detectedType} | Pedimento: ${detection.detectedPedimento || 'N/A'} | RFC: ${detection.fields?.rfc || 'N/A'}`,
-              );
-            } else {
-              logger.info(
-                `Not detected: ${record.filename} - No pedimento-simplificado pattern found`,
+              updatePromises.push(
+                supabase
+                  .from('uploader')
+                  .update({
+                    status: 'detection-error',
+                    message: error.message,
+                  })
+                  .eq('id', record.id),
               );
             }
+          }
 
-            updatePromises.push(
-              supabase.from('uploader').update(updateData).eq('id', record.id),
-            );
+          try {
+            await Promise.all(updatePromises);
           } catch (error) {
-            logger.error(`Error detecting ${record.filename}: ${error.message}`);
-            chunkErrors++;
-            totalErrors++;
-
-            updatePromises.push(
-              supabase
-                .from('uploader')
-                .update({
-                  status: 'detection-error',
-                  message: error.message,
-                })
-                .eq('id', record.id),
+            logger.error(
+              `Error updating batch in chunk ${chunkNumber}: ${error.message}`,
             );
           }
         }
 
-        try {
-          await Promise.all(updatePromises);
-        } catch (error) {
-          logger.error(`Error updating batch in chunk ${chunkNumber}: ${error.message}`);
-        }
-      }
+        logger.success(
+          `Chunk ${chunkNumber} completed: ${chunkDetected} detected, ${chunkProcessed} processed, ${chunkErrors} errors`,
+        );
 
-      logger.success(
-        `Chunk ${chunkNumber} completed: ${chunkDetected} detected, ${chunkProcessed} processed, ${chunkErrors} errors`,
-      );
+        offset += queryBatchSize;
+        chunkNumber++;
 
-      offset += queryBatchSize;
-      chunkNumber++;
+        if (pdfRecords.length < queryBatchSize) {
+          logger.info(
+            `Reached end of records (chunk had ${pdfRecords.length} records).`,
+          );
+          break;
+        }
 
-      if (pdfRecords.length < queryBatchSize) {
-        logger.info(`Reached end of records (chunk had ${pdfRecords.length} records).`);
-        break;
+        // Small delay between chunks
+        await new Promise((resolve) => setTimeout(resolve, 500));
+      } catch (chunkError) {
+        logger.error(
+          `Error processing chunk ${chunkNumber}: ${chunkError.message}`,
+        );
+        // Continue to next chunk after error
+        offset += queryBatchSize;
+        chunkNumber++;
+        totalErrors++;
+        continue;
       }
-
-      // Small delay between chunks
-      await new Promise((resolve) => setTimeout(resolve, 500));
     }
 
     const result = {
@@ -427,7 +521,7 @@ export class DatabaseService {
    */
   async propagateArelaPath(options = {}) {
     const supabase = await this.#getSupabaseClient();
-    
+
     logger.info('Phase 3: Starting arela_path propagation process...');
     console.log('🔍 Finding pedimento_simplificado records with arela_path...');
 
@@ -446,12 +540,18 @@ export class DatabaseService {
 
     if (!pedimentoRecords || pedimentoRecords.length === 0) {
       logger.info('No pedimento_simplificado records with arela_path found');
-      console.log('ℹ️  No pedimento_simplificado records with arela_path found');
+      console.log(
+        'ℹ️  No pedimento_simplificado records with arela_path found',
+      );
       return { processedCount: 0, updatedCount: 0, errorCount: 0 };
     }
 
-    console.log(`📋 Found ${pedimentoRecords.length} pedimento records with arela_path`);
-    logger.info(`Found ${pedimentoRecords.length} pedimento records with arela_path to process`);
+    console.log(
+      `📋 Found ${pedimentoRecords.length} pedimento records with arela_path`,
+    );
+    logger.info(
+      `Found ${pedimentoRecords.length} pedimento records with arela_path to process`,
+    );
 
     let totalProcessed = 0;
     let totalUpdated = 0;
@@ -465,8 +565,10 @@ export class DatabaseService {
 
         // Extract base path from original_path (remove filename)
         const basePath = path.dirname(pedimento.original_path);
-        
-        logger.info(`Processing pedimento: ${pedimento.filename} | Base path: ${basePath}`);
+
+        logger.info(
+          `Processing pedimento: ${pedimento.filename} | Base path: ${basePath}`,
+        );
 
         // Extract folder part from existing arela_path
         const existingPath = pedimento.arela_path;
@@ -485,7 +587,9 @@ export class DatabaseService {
           .neq('id', pedimento.id); // Exclude the pedimento itself
 
         if (relatedError) {
-          logger.error(`Error finding related files for ${pedimento.filename}: ${relatedError.message}`);
+          logger.error(
+            `Error finding related files for ${pedimento.filename}: ${relatedError.message}`,
+          );
           totalErrors++;
           continue;
         }
@@ -495,17 +599,21 @@ export class DatabaseService {
           continue;
         }
 
-        logger.info(`Found ${relatedFiles.length} related files to update for ${pedimento.filename}`);
+        logger.info(
+          `Found ${relatedFiles.length} related files to update for ${pedimento.filename}`,
+        );
 
         // Process files in batches
         const fileIds = relatedFiles.map((f) => f.id);
-        
+
         for (let i = 0; i < fileIds.length; i += BATCH_SIZE) {
           const batchIds = fileIds.slice(i, i + BATCH_SIZE);
           const batchNumber = Math.floor(i / BATCH_SIZE) + 1;
           const totalBatches = Math.ceil(fileIds.length / BATCH_SIZE);
 
-          logger.info(`Batch ${batchNumber}/${totalBatches}: Updating ${batchIds.length} files...`);
+          logger.info(
+            `Batch ${batchNumber}/${totalBatches}: Updating ${batchIds.length} files...`,
+          );
 
           try {
             const { error: updateError } = await supabase
@@ -514,19 +622,27 @@ export class DatabaseService {
               .in('id', batchIds);
 
             if (updateError) {
-              logger.error(`Error in batch ${batchNumber}: ${updateError.message}`);
+              logger.error(
+                `Error in batch ${batchNumber}: ${updateError.message}`,
+              );
               totalErrors++;
             } else {
               totalUpdated += batchIds.length;
-              logger.info(`Successfully updated batch ${batchNumber}: ${batchIds.length} files`);
+              logger.info(
+                `Successfully updated batch ${batchNumber}: ${batchIds.length} files`,
+              );
             }
           } catch (batchError) {
-            logger.error(`Exception in batch ${batchNumber}: ${batchError.message}`);
+            logger.error(
+              `Exception in batch ${batchNumber}: ${batchError.message}`,
+            );
             totalErrors++;
           }
         }
       } catch (error) {
-        logger.error(`Error processing pedimento ${pedimento.filename}: ${error.message}`);
+        logger.error(
+          `Error processing pedimento ${pedimento.filename}: ${error.message}`,
+        );
         totalErrors++;
       }
     }
@@ -552,12 +668,15 @@ export class DatabaseService {
   async uploadFilesByRfc(options = {}) {
     const supabase = await this.#getSupabaseClient();
     const uploadService = await uploadServiceFactory.getUploadService();
-    
+
     // Get configuration
-    const appConfig = await import('../config/config.js').then(m => m.appConfig);
-    
+    const appConfig = await import('../config/config.js').then(
+      (m) => m.appConfig,
+    );
+
     if (!appConfig.upload.rfcs || appConfig.upload.rfcs.length === 0) {
-      const errorMsg = 'No RFCs specified. Please set UPLOAD_RFCS environment variable with pipe-separated RFC values.';
+      const errorMsg =
+        'No RFCs specified. Please set UPLOAD_RFCS environment variable with pipe-separated RFC values.';
       logger.error(errorMsg);
       throw new Error(errorMsg);
     }
@@ -582,13 +701,16 @@ export class DatabaseService {
     }
 
     // Step 1: Get all pedimento_simplificado records that match the specified RFCs and have arela_path
-    console.log('🎯 Finding pedimento_simplificado records for specified RFCs...');
-    const { data: pedimentoRfcRecords, error: pedimentoRfcError } = await supabase
-      .from('uploader')
-      .select('arela_path')
-      .eq('document_type', 'pedimento_simplificado')
-      .in('rfc', appConfig.upload.rfcs)
-      .not('arela_path', 'is', null);
+    console.log(
+      '🎯 Finding pedimento_simplificado records for specified RFCs...',
+    );
+    const { data: pedimentoRfcRecords, error: pedimentoRfcError } =
+      await supabase
+        .from('uploader')
+        .select('arela_path')
+        .eq('document_type', 'pedimento_simplificado')
+        .in('rfc', appConfig.upload.rfcs)
+        .not('arela_path', 'is', null);
 
     if (pedimentoRfcError) {
       const errorMsg = `Error fetching pedimento RFC records: ${pedimentoRfcError.message}`;
@@ -597,15 +719,23 @@ export class DatabaseService {
     }
 
     if (!pedimentoRfcRecords || pedimentoRfcRecords.length === 0) {
-      console.log('ℹ️  No pedimento_simplificado records found for the specified RFCs with arela_path');
+      console.log(
+        'ℹ️  No pedimento_simplificado records found for the specified RFCs with arela_path',
+      );
       logger.info('No pedimento_simplificado records found for specified RFCs');
       return { processedCount: 0, uploadedCount: 0, errorCount: 0 };
     }
 
     // Get unique arela_paths from pedimento records
-    const uniqueArelaPaths = [...new Set(pedimentoRfcRecords.map((r) => r.arela_path))];
-    console.log(`📋 Found ${pedimentoRfcRecords.length} pedimento records with ${uniqueArelaPaths.length} unique arela_paths for specified RFCs`);
-    logger.info(`Found ${pedimentoRfcRecords.length} pedimento records with ${uniqueArelaPaths.length} unique arela_paths`);
+    const uniqueArelaPaths = [
+      ...new Set(pedimentoRfcRecords.map((r) => r.arela_path)),
+    ];
+    console.log(
+      `📋 Found ${pedimentoRfcRecords.length} pedimento records with ${uniqueArelaPaths.length} unique arela_paths for specified RFCs`,
+    );
+    logger.info(
+      `Found ${pedimentoRfcRecords.length} pedimento records with ${uniqueArelaPaths.length} unique arela_paths`,
+    );
 
     // Step 2: Get all files with these arela_paths that haven't been uploaded yet
     let rfcRecords = [];
@@ -634,41 +764,64 @@ export class DatabaseService {
 
     if (!rfcRecords || rfcRecords.length === 0) {
       if (totalRfcFiles && totalRfcFiles > 0) {
-        console.log(`ℹ️  All ${totalRfcFiles} files for the specified RFCs are already uploaded (status: file-uploaded)`);
+        console.log(
+          `ℹ️  All ${totalRfcFiles} files for the specified RFCs are already uploaded (status: file-uploaded)`,
+        );
         console.log('   No new files to upload.');
-        logger.info(`All ${totalRfcFiles} files for specified RFCs already uploaded`);
+        logger.info(
+          `All ${totalRfcFiles} files for specified RFCs already uploaded`,
+        );
       } else {
-        console.log('ℹ️  No files found for the specified RFCs with arela_path');
-        console.log(`   Make sure files for RFCs [${appConfig.upload.rfcs.join(', ')}] have been processed and have arela_path values`);
+        console.log(
+          'ℹ️  No files found for the specified RFCs with arela_path',
+        );
+        console.log(
+          `   Make sure files for RFCs [${appConfig.upload.rfcs.join(', ')}] have been processed and have arela_path values`,
+        );
         logger.info('No files found for specified RFCs with arela_path');
       }
       return { processedCount: 0, uploadedCount: 0, errorCount: 0 };
     }
 
     // Show filtering effect
-    const uploadableArelaPaths = [...new Set(rfcRecords.map((r) => r.arela_path))];
+    const uploadableArelaPaths = [
+      ...new Set(rfcRecords.map((r) => r.arela_path)),
+    ];
     const skipped = (totalRfcFiles || 0) - rfcRecords.length;
     if (skipped > 0) {
-      console.log(`📊 Found ${rfcRecords.length} files ready for upload (${skipped} already uploaded, skipped)`);
+      console.log(
+        `📊 Found ${rfcRecords.length} files ready for upload (${skipped} already uploaded, skipped)`,
+      );
     } else {
       console.log(`📊 Found ${rfcRecords.length} files ready for upload`);
     }
-    logger.info(`Found ${rfcRecords.length} files ready for upload, ${skipped} skipped`);
+    logger.info(
+      `Found ${rfcRecords.length} files ready for upload, ${skipped} skipped`,
+    );
 
     // Step 3: Get ALL files that have these arela_paths (including supporting documents)
     let allRelatedFiles = [];
     const arelaPathChunkSize = 50;
     const queryBatchSize = 1000;
 
-    console.log('📥 Fetching all related files (processing arela_paths in chunks to avoid URI limits)...');
+    console.log(
+      '📥 Fetching all related files (processing arela_paths in chunks to avoid URI limits)...',
+    );
 
     // Process arela_paths in chunks
     for (let i = 0; i < uploadableArelaPaths.length; i += arelaPathChunkSize) {
-      const arelaPathChunk = uploadableArelaPaths.slice(i, i + arelaPathChunkSize);
+      const arelaPathChunk = uploadableArelaPaths.slice(
+        i,
+        i + arelaPathChunkSize,
+      );
       const chunkNumber = Math.floor(i / arelaPathChunkSize) + 1;
-      const totalChunks = Math.ceil(uploadableArelaPaths.length / arelaPathChunkSize);
-      
-      console.log(`   Processing arela_path chunk ${chunkNumber}/${totalChunks} (${arelaPathChunk.length} paths)`);
+      const totalChunks = Math.ceil(
+        uploadableArelaPaths.length / arelaPathChunkSize,
+      );
+
+      console.log(
+        `   Processing arela_path chunk ${chunkNumber}/${totalChunks} (${arelaPathChunk.length} paths)`,
+      );
 
       // For each chunk of arela_paths, use pagination to get all related files
       let hasMore = true;
@@ -715,14 +868,16 @@ export class DatabaseService {
 
     for (let i = 0; i < allRelatedFiles.length; i += batchSize) {
       const batch = allRelatedFiles.slice(i, i + batchSize);
-      
+
       for (const file of batch) {
         try {
           totalProcessed++;
-          
+
           // Check if file exists
           if (!fs.existsSync(file.original_path)) {
-            logger.warn(`File not found: ${file.filename} at ${file.original_path}`);
+            logger.warn(
+              `File not found: ${file.filename} at ${file.original_path}`,
+            );
             await supabase
               .from('uploader')
               .update({
@@ -749,14 +904,19 @@ export class DatabaseService {
               // Fallback to RFC folder
               uploadPath = `uploads/${file.rfc}/${file.filename}`;
             }
-            
-            uploadResult = await uploadService.upload([{
-              path: file.original_path,
-              name: file.filename,
-              contentType: 'application/octet-stream',
-            }], {
-              uploadPath: uploadPath,
-            });
+
+            uploadResult = await uploadService.upload(
+              [
+                {
+                  path: file.original_path,
+                  name: file.filename,
+                  contentType: 'application/octet-stream',
+                },
+              ],
+              {
+                uploadPath: uploadPath,
+              },
+            );
             uploadResult = { success: true, data: uploadResult };
           } else {
             // API service supports batch uploads and returns normalized response
@@ -771,14 +931,19 @@ export class DatabaseService {
               // Fallback to RFC folder
               fullFolderStructure = `${file.rfc}/`;
             }
-            
-            uploadResult = await uploadService.upload([{
-              path: file.original_path,
-              name: file.filename,
-              contentType: 'application/octet-stream',
-            }], {
-              folderStructure: fullFolderStructure,
-            });
+
+            uploadResult = await uploadService.upload(
+              [
+                {
+                  path: file.original_path,
+                  name: file.filename,
+                  contentType: 'application/octet-stream',
+                },
+              ],
+              {
+                folderStructure: fullFolderStructure,
+              },
+            );
           }
 
           if (uploadResult.success) {
@@ -790,7 +955,7 @@ export class DatabaseService {
                 message: 'Successfully uploaded to Arela API',
               })
               .eq('id', file.id);
-            
+
             totalUploaded++;
             logger.info(`Uploaded: ${file.filename}`);
           } else {
@@ -801,14 +966,18 @@ export class DatabaseService {
                 message: uploadResult.error || 'Upload failed',
               })
               .eq('id', file.id);
-            
+
             totalErrors++;
-            logger.error(`Upload failed: ${file.filename} - ${uploadResult.error}`);
+            logger.error(
+              `Upload failed: ${file.filename} - ${uploadResult.error}`,
+            );
           }
         } catch (error) {
           totalErrors++;
-          logger.error(`Error processing file ${file.filename}: ${error.message}`);
-          
+          logger.error(
+            `Error processing file ${file.filename}: ${error.message}`,
+          );
+
           await supabase
             .from('uploader')
             .update({
@@ -859,15 +1028,21 @@ export class DatabaseService {
     // Check if UPLOAD_RFCS is configured
     const uploadRfcs = appConfig.upload.rfcs;
     if (!uploadRfcs || uploadRfcs.length === 0) {
-      console.log('ℹ️  No UPLOAD_RFCS configured. Please set UPLOAD_RFCS environment variable to see files ready for upload.');
-      console.log('   Example: UPLOAD_RFCS="RFC123456789|RFC987654321|RFC555444333"');
+      console.log(
+        'ℹ️  No UPLOAD_RFCS configured. Please set UPLOAD_RFCS environment variable to see files ready for upload.',
+      );
+      console.log(
+        '   Example: UPLOAD_RFCS="RFC123456789|RFC987654321|RFC555444333"',
+      );
       return [];
     }
 
     console.log(`🎯 Using RFC filter: ${uploadRfcs.join(', ')}`);
 
     // Step 1: Find pedimento_simplificado documents for the specified RFCs that have arela_path
-    console.log('🎯 Finding pedimento_simplificado documents for specified RFCs with arela_path...');
+    console.log(
+      '🎯 Finding pedimento_simplificado documents for specified RFCs with arela_path...',
+    );
     const { data: pedimentoRecords, error: pedimentoError } = await supabase
       .from('uploader')
       .select('arela_path')
@@ -876,17 +1051,25 @@ export class DatabaseService {
       .not('arela_path', 'is', null);
 
     if (pedimentoError) {
-      throw new Error(`Error querying pedimento_simplificado records: ${pedimentoError.message}`);
+      throw new Error(
+        `Error querying pedimento_simplificado records: ${pedimentoError.message}`,
+      );
     }
 
     if (!pedimentoRecords || pedimentoRecords.length === 0) {
-      console.log('ℹ️  No pedimento_simplificado records with arela_path found');
+      console.log(
+        'ℹ️  No pedimento_simplificado records with arela_path found',
+      );
       return [];
     }
 
     // Get unique arela_paths
-    const uniqueArelaPaths = [...new Set(pedimentoRecords.map(r => r.arela_path))];
-    console.log(`📋 Found ${pedimentoRecords.length} pedimento records with ${uniqueArelaPaths.length} unique arela_paths`);
+    const uniqueArelaPaths = [
+      ...new Set(pedimentoRecords.map((r) => r.arela_path)),
+    ];
+    console.log(
+      `📋 Found ${pedimentoRecords.length} pedimento records with ${uniqueArelaPaths.length} unique arela_paths`,
+    );
 
     // Step 2: Find all related files with these arela_paths that haven't been uploaded yet
     console.log('🔍 Finding all related files that need to be uploaded...');
@@ -900,13 +1083,17 @@ export class DatabaseService {
 
       const { data: chunkFiles, error: chunkError } = await supabase
         .from('uploader')
-        .select('id, original_path, arela_path, filename, rfc, document_type, status')
+        .select(
+          'id, original_path, arela_path, filename, rfc, document_type, status',
+        )
         .in('arela_path', pathChunk)
         .neq('status', 'file-uploaded')
         .not('original_path', 'is', null);
 
       if (chunkError) {
-        throw new Error(`Error querying files for arela_paths chunk: ${chunkError.message}`);
+        throw new Error(
+          `Error querying files for arela_paths chunk: ${chunkError.message}`,
+        );
       }
 
       if (chunkFiles && chunkFiles.length > 0) {
@@ -950,4 +1137,4 @@ export class DatabaseService {
 
 // Export singleton instance
 export const databaseService = new DatabaseService();
-export default databaseService;
+export default databaseService;