@arela/uploader 0.2.8 → 0.2.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arela/uploader",
-  "version": "0.2.8",
+  "version": "0.2.10",
   "description": "CLI to upload files/directories to Arela",
   "bin": {
     "arela": "./src/index.js"

package/src/config/config.js

@@ -28,10 +28,10 @@ class Config {
       const __dirname = path.dirname(__filename);
       const packageJsonPath = path.resolve(__dirname, '../../package.json');
       const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
-      return packageJson.version || '0.2.8';
+      return packageJson.version || '0.2.10';
     } catch (error) {
       console.warn('⚠️ Could not read package.json version, using fallback');
-      return '0.2.8';
+      return '0.2.10';
     }
   }
 
@@ -72,10 +72,15 @@ class Config {
       .map((s) => s.trim())
       .filter(Boolean);
 
+    const uploadYears = process.env.UPLOAD_YEARS?.split('|')
+      .map((s) => s.trim())
+      .filter(Boolean);
+
     return {
       basePath,
       sources,
       rfcs: uploadRfcs,
+      years: uploadYears,
     };
   }
 

package/src/services/DatabaseService.js

@@ -557,135 +557,226 @@ export class DatabaseService {
     const supabase = await this.#getSupabaseClient();
 
     logger.info('Phase 3: Starting arela_path and year propagation process...');
-    console.log(
-      '🔍 Finding pedimento_simplificado records with arela_path and year...',
-    );
-
-    // Get all pedimento_simplificado records that have arela_path
-    const { data: pedimentoRecords, error: pedimentoError } = await supabase
-      .from('uploader')
-      .select('id, original_path, arela_path, filename, year')
-      .eq('document_type', 'pedimento_simplificado')
-      .not('arela_path', 'is', null);
-
-    if (pedimentoError) {
-      const errorMsg = `Error fetching pedimento records: ${pedimentoError.message}`;
-      logger.error(errorMsg);
-      throw new Error(errorMsg);
-    }
+    console.log('🔍 Processing pedimento_simplificado records page by page...');
 
-    if (!pedimentoRecords || pedimentoRecords.length === 0) {
-      logger.info('No pedimento_simplificado records with arela_path found');
+    // Log year filtering configuration
+    if (appConfig.upload.years && appConfig.upload.years.length > 0) {
+      logger.info(
+        `🗓️  Year filter enabled: ${appConfig.upload.years.join(', ')}`,
+      );
       console.log(
-        'ℹ️  No pedimento_simplificado records with arela_path found',
+        `🗓️  Year filter enabled: ${appConfig.upload.years.join(', ')}`,
       );
-      return { processedCount: 0, updatedCount: 0, errorCount: 0 };
+    } else {
+      logger.info('🗓️  No year filter configured - processing all years');
+      console.log('🗓️  No year filter configured - processing all years');
     }
 
-    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;
     let totalErrors = 0;
+    let offset = 0;
+    const pageSize = 50;
+    let hasMoreData = true;
+    let pageNumber = 1;
     const BATCH_SIZE = 50; // Process files in batches
 
-    // Process each pedimento record
-    for (const pedimento of pedimentoRecords) {
-      try {
-        totalProcessed++;
+    // Process pedimento records page by page for memory efficiency
+    while (hasMoreData) {
+      logger.info(
+        `Fetching and processing pedimento records page ${pageNumber} (records ${offset + 1} to ${offset + pageSize})...`,
+      );
+
+      let query = supabase
+        .from('uploader')
+        .select('id, original_path, arela_path, filename, year')
+        .eq('document_type', 'pedimento_simplificado')
+        .not('arela_path', 'is', null);
 
-        // Extract base path from original_path (remove filename)
-        const basePath = path.dirname(pedimento.original_path);
+      // Add year filter if UPLOAD_YEARS is configured
+      if (appConfig.upload.years && appConfig.upload.years.length > 0) {
+        query = query.in('year', appConfig.upload.years);
+      }
 
-        logger.info(
-          `Processing pedimento: ${pedimento.filename} | Base path: ${basePath} | Year: ${pedimento.year || 'N/A'}`,
-        );
+      const { data: pedimentoPage, error: pedimentoError } = await query
+        .range(offset, offset + pageSize - 1)
+        .order('created_at');
 
-        // Extract folder part from existing arela_path
-        const existingPath = pedimento.arela_path;
-        const folderArelaPath = existingPath.includes('/')
-          ? existingPath.substring(0, existingPath.lastIndexOf('/')) + '/'
-          : existingPath.endsWith('/')
-            ? existingPath
-            : existingPath + '/';
+      if (pedimentoError) {
+        const errorMsg = `Error fetching pedimento records page ${pageNumber}: ${pedimentoError.message}`;
+        logger.error(errorMsg);
+        throw new Error(errorMsg);
+      }
 
-        // Find all files with the same base path that don't have arela_path yet
-        const { data: relatedFiles, error: relatedError } = await supabase
-          .from('uploader')
-          .select('id, filename, original_path')
-          .like('original_path', `${basePath}%`)
-          .is('arela_path', null)
-          .neq('id', pedimento.id); // Exclude the pedimento itself
+      if (!pedimentoPage || pedimentoPage.length === 0) {
+        hasMoreData = false;
+        logger.info('No more pedimento records found');
+        break;
+      }
 
-        if (relatedError) {
-          logger.error(
-            `Error finding related files for ${pedimento.filename}: ${relatedError.message}`,
-          );
-          totalErrors++;
-          continue;
-        }
+      logger.info(
+        `Processing page ${pageNumber}: ${pedimentoPage.length} pedimento records`,
+      );
 
-        if (!relatedFiles || relatedFiles.length === 0) {
-          logger.info(`No related files found for ${pedimento.filename}`);
-          continue;
-        }
+      // Process each pedimento record in the current page
+      for (const pedimento of pedimentoPage) {
+        try {
+          totalProcessed++;
 
-        logger.info(
-          `Found ${relatedFiles.length} related files to update for ${pedimento.filename}`,
-        );
+          // Extract base path from original_path (remove filename)
+          const basePath = path.dirname(pedimento.original_path);
 
-        // Process files in batches
-        const fileIds = relatedFiles.map((f) => f.id);
+          logger.info(
+            `Processing pedimento: ${pedimento.filename} | Base path: ${basePath} | Year: ${pedimento.year || 'N/A'}`,
+          );
 
-        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);
+          // Extract folder part from existing arela_path
+          const existingPath = pedimento.arela_path;
+          const folderArelaPath = existingPath.includes('/')
+            ? existingPath.substring(0, existingPath.lastIndexOf('/')) + '/'
+            : existingPath.endsWith('/')
+              ? existingPath
+              : existingPath + '/';
+
+          // Process related files page by page for memory efficiency
+          let relatedFilesFrom = 0;
+          const relatedFilesPageSize = 50;
+          let hasMoreRelatedFiles = true;
+          let relatedFilesPageNumber = 1;
+          let totalRelatedFilesProcessed = 0;
 
           logger.info(
-            `Batch ${batchNumber}/${totalBatches}: Updating ${batchIds.length} files...`,
+            `Searching and processing related files in base path: ${basePath}`,
           );
 
-          try {
-            const { error: updateError } = await supabase
-              .from('uploader')
-              .update({
-                arela_path: folderArelaPath,
-                year: pedimento.year,
-              })
-              .in('id', batchIds);
+          while (hasMoreRelatedFiles) {
+            const { data: relatedFilesPage, error: relatedError } =
+              await supabase
+                .from('uploader')
+                .select('id, filename, original_path')
+                .like('original_path', `${basePath}%`)
+                .is('arela_path', null)
+                .neq('id', pedimento.id) // Exclude the pedimento itself
+                .range(
+                  relatedFilesFrom,
+                  relatedFilesFrom + relatedFilesPageSize - 1,
+                );
 
-            if (updateError) {
+            if (relatedError) {
               logger.error(
-                `Error in batch ${batchNumber}: ${updateError.message}`,
+                `Error finding related files for ${pedimento.filename}: ${relatedError.message}`,
               );
               totalErrors++;
+              break;
+            }
+
+            if (!relatedFilesPage || relatedFilesPage.length === 0) {
+              hasMoreRelatedFiles = false;
+              if (totalRelatedFilesProcessed === 0) {
+                logger.info(`No related files found for ${pedimento.filename}`);
+              }
+              break;
+            }
+
+            logger.info(
+              `Processing related files page ${relatedFilesPageNumber}: ${relatedFilesPage.length} files for ${pedimento.filename}`,
+            );
+
+            // Process this page of related files in batches
+            const pageFileIds = relatedFilesPage.map((f) => f.id);
+
+            for (let i = 0; i < pageFileIds.length; i += BATCH_SIZE) {
+              const batchIds = pageFileIds.slice(i, i + BATCH_SIZE);
+              const batchNumber =
+                Math.floor(relatedFilesFrom / BATCH_SIZE) +
+                Math.floor(i / BATCH_SIZE) +
+                1;
+
+              logger.info(
+                `Updating batch ${batchNumber}: ${batchIds.length} files with arela_path and year...`,
+              );
+
+              try {
+                const { error: updateError } = await supabase
+                  .from('uploader')
+                  .update({
+                    arela_path: folderArelaPath,
+                    year: pedimento.year,
+                  })
+                  .in('id', batchIds);
+
+                if (updateError) {
+                  logger.error(
+                    `Error in batch ${batchNumber}: ${updateError.message}`,
+                  );
+                  totalErrors++;
+                } else {
+                  totalUpdated += batchIds.length;
+                  totalRelatedFilesProcessed += batchIds.length;
+                  logger.info(
+                    `Successfully updated batch ${batchNumber}: ${batchIds.length} files with arela_path and year`,
+                  );
+                }
+              } catch (batchError) {
+                logger.error(
+                  `Exception in batch ${batchNumber}: ${batchError.message}`,
+                );
+                totalErrors++;
+              }
+            }
+
+            // Check if we need to fetch the next page of related files
+            if (relatedFilesPage.length < relatedFilesPageSize) {
+              hasMoreRelatedFiles = false;
+              logger.info(
+                `Completed processing related files for ${pedimento.filename}. Total processed: ${totalRelatedFilesProcessed}`,
+              );
             } else {
-              totalUpdated += batchIds.length;
+              relatedFilesFrom += relatedFilesPageSize;
+              relatedFilesPageNumber++;
               logger.info(
-                `Successfully updated batch ${batchNumber}: ${batchIds.length} files with arela_path and year`,
+                `Page ${relatedFilesPageNumber - 1} complete: ${relatedFilesPage.length} files processed, continuing to next page...`,
               );
             }
-          } catch (batchError) {
-            logger.error(
-              `Exception in batch ${batchNumber}: ${batchError.message}`,
-            );
-            totalErrors++;
           }
+        } catch (error) {
+          logger.error(
+            `Error processing pedimento ${pedimento.filename}: ${error.message}`,
+          );
+          totalErrors++;
         }
-      } catch (error) {
-        logger.error(
-          `Error processing pedimento ${pedimento.filename}: ${error.message}`,
+      }
+
+      // Check if we need to fetch the next page
+      if (pedimentoPage.length < pageSize) {
+        hasMoreData = false;
+        logger.info(
+          `Completed processing. Last page ${pageNumber} had ${pedimentoPage.length} records`,
+        );
+      } else {
+        offset += pageSize;
+        pageNumber++;
+        logger.info(
+          `Page ${pageNumber - 1} complete: ${pedimentoPage.length} records processed, moving to next page...`,
         );
-        totalErrors++;
       }
     }
 
+    // Final summary
+    if (totalProcessed === 0) {
+      logger.info('No pedimento_simplificado records with arela_path found');
+      console.log(
+        'ℹ️  No pedimento_simplificado records with arela_path found',
+      );
+    } else {
+      console.log(
+        `📋 Processed ${totalProcessed} pedimento records across ${pageNumber - 1} pages`,
+      );
+      logger.info(
+        `Processed ${totalProcessed} pedimento records across ${pageNumber - 1} pages`,
+      );
+    }
+
     const result = {
       processedCount: totalProcessed,
       updatedCount: totalUpdated,
@@ -743,13 +834,21 @@ export class DatabaseService {
     console.log(
       '🎯 Finding pedimento_simplificado records for specified RFCs...',
     );
+
+    let pedimentoQuery = supabase
+      .from('uploader')
+      .select('arela_path')
+      .eq('document_type', 'pedimento_simplificado')
+      .in('rfc', appConfig.upload.rfcs)
+      .not('arela_path', 'is', null);
+
+    // Add year filter if UPLOAD_YEARS is configured
+    if (appConfig.upload.years && appConfig.upload.years.length > 0) {
+      pedimentoQuery = pedimentoQuery.in('year', appConfig.upload.years);
+    }
+
     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);
+      await pedimentoQuery;
 
     if (pedimentoRfcError) {
       const errorMsg = `Error fetching pedimento RFC records: ${pedimentoRfcError.message}`;
@@ -1003,13 +1102,25 @@ export class DatabaseService {
     console.log(
       '🎯 Finding pedimento_simplificado documents for specified RFCs with arela_path...',
     );
-    const { data: pedimentoRecords, error: pedimentoError } = await supabase
+
+    let pedimentoReadyQuery = supabase
       .from('uploader')
       .select('arela_path')
       .eq('document_type', 'pedimento_simplificado')
       .in('rfc', uploadRfcs)
       .not('arela_path', 'is', null);
 
+    // Add year filter if UPLOAD_YEARS is configured
+    if (appConfig.upload.years && appConfig.upload.years.length > 0) {
+      pedimentoReadyQuery = pedimentoReadyQuery.in(
+        'year',
+        appConfig.upload.years,
+      );
+    }
+
+    const { data: pedimentoRecords, error: pedimentoError } =
+      await pedimentoReadyQuery;
+
     if (pedimentoError) {
       throw new Error(
         `Error querying pedimento_simplificado records: ${pedimentoError.message}`,
@@ -1041,22 +1152,44 @@ export class DatabaseService {
     for (let i = 0; i < uniqueArelaPaths.length; i += chunkSize) {
       const pathChunk = uniqueArelaPaths.slice(i, i + chunkSize);
 
-      const { data: chunkFiles, error: chunkError } = await supabase
-        .from('uploader')
-        .select(
-          'id, original_path, arela_path, filename, rfc, document_type, status',
-        )
-        .in('arela_path', pathChunk)
-        .neq('status', 'file-uploaded')
-        .not('original_path', 'is', null);
+      // Query with pagination to get all results (Supabase default limit is 1000)
+      let chunkFiles = [];
+      let from = 0;
+      const pageSize = 1000;
+      let hasMoreData = true;
 
-      if (chunkError) {
-        throw new Error(
-          `Error querying files for arela_paths chunk: ${chunkError.message}`,
-        );
+      while (hasMoreData) {
+        const { data: pageData, error: chunkError } = await supabase
+          .from('uploader')
+          .select(
+            'id, original_path, arela_path, filename, rfc, document_type, status',
+          )
+          .in('arela_path', pathChunk)
+          .neq('status', 'file-uploaded')
+          .not('original_path', 'is', null)
+          .range(from, from + pageSize - 1);
+
+        if (chunkError) {
+          throw new Error(
+            `Error querying files for arela_paths chunk: ${chunkError.message}`,
+          );
+        }
+
+        if (pageData && pageData.length > 0) {
+          chunkFiles = chunkFiles.concat(pageData);
+
+          // Check if we got a full page, indicating there might be more data
+          if (pageData.length < pageSize) {
+            hasMoreData = false;
+          } else {
+            from += pageSize;
+          }
+        } else {
+          hasMoreData = false;
+        }
       }
 
-      if (chunkFiles && chunkFiles.length > 0) {
+      if (chunkFiles.length > 0) {
         allReadyFiles = allReadyFiles.concat(chunkFiles);
       }
     }
@@ -1242,17 +1375,36 @@ export class DatabaseService {
         { uploadPath: uploadPath },
       );
 
-      // Update database status
-      await supabase
-        .from('uploader')
-        .update({
-          status: 'file-uploaded',
-          message: 'Successfully uploaded to Supabase',
-        })
-        .eq('id', file.id);
+      // Check upload result before updating database status
+      if (uploadResult.success) {
+        await supabase
+          .from('uploader')
+          .update({
+            status: 'file-uploaded',
+            message: 'Successfully uploaded to Supabase',
+          })
+          .eq('id', file.id);
+
+        logger.info(`✅ Uploaded: ${file.filename}`);
+        return { success: true, filename: file.filename };
+      } else {
+        await supabase
+          .from('uploader')
+          .update({
+            status: 'upload-error',
+            message: `Upload failed: ${uploadResult.error}`,
+          })
+          .eq('id', file.id);
 
-      logger.info(`✅ Uploaded: ${file.filename}`);
-      return { success: true, filename: file.filename };
+        logger.error(
+          `❌ Upload failed: ${file.filename} - ${uploadResult.error}`,
+        );
+        return {
+          success: false,
+          error: uploadResult.error,
+          filename: file.filename,
+        };
+      }
     } catch (error) {
       logger.error(
         `❌ Error processing file ${file.filename}: ${error.message}`,
@@ -1335,23 +1487,188 @@ export class DatabaseService {
           { folderStructure: fullFolderStructure },
         );
 
-        if (uploadResult.success) {
-          // Update all files as uploaded
-          const fileIds = validFiles.map((f) => f.dbRecord.id);
-          await supabase
-            .from('uploader')
-            .update({
-              status: 'file-uploaded',
-              message: 'Successfully uploaded to Arela API (batch)',
-            })
-            .in('id', fileIds);
+        if (uploadResult.success && uploadResult.data) {
+          const apiResult = uploadResult.data;
 
-          uploaded += validFiles.length;
           logger.info(
-            `✅ Batch uploaded: ${validFiles.length} files to ${fullFolderStructure}`,
+            `📋 Processing API response: ${apiResult.uploaded?.length || 0} uploaded, ${apiResult.errors?.length || 0} errors`,
+          );
+
+          // Debug logging to understand API response structure
+          logger.debug(
+            `🔍 API Response structure: ${JSON.stringify(apiResult, null, 2)}`,
+          );
+          if (apiResult.uploaded && apiResult.uploaded.length > 0) {
+            logger.debug(
+              `🔍 First uploaded file structure: ${JSON.stringify(apiResult.uploaded[0], null, 2)}`,
+            );
+          }
+
+          // Create filename to file mapping for quick lookup
+          const fileNameToRecord = new Map();
+          validFiles.forEach((f) => {
+            fileNameToRecord.set(f.fileData.name, f.dbRecord);
+          });
+
+          // Debug: Log expected filenames
+          logger.debug(
+            `🔍 Expected filenames: ${Array.from(fileNameToRecord.keys()).join(', ')}`,
+          );
+
+          // Handle successfully uploaded files
+          if (apiResult.uploaded && apiResult.uploaded.length > 0) {
+            const successfulFileIds = [];
+            const matchedFilenames = [];
+
+            apiResult.uploaded.forEach((uploadedFile) => {
+              // Try multiple possible property names for filename
+              const possibleFilename =
+                uploadedFile.fileName ||
+                uploadedFile.filename ||
+                uploadedFile.name ||
+                uploadedFile.file_name ||
+                uploadedFile.originalName ||
+                uploadedFile.original_name;
+
+              logger.debug(
+                `🔍 Trying to match uploaded file: ${JSON.stringify(uploadedFile)}`,
+              );
+
+              const dbRecord = fileNameToRecord.get(possibleFilename);
+              if (dbRecord) {
+                successfulFileIds.push(dbRecord.id);
+                matchedFilenames.push(possibleFilename);
+                logger.debug(`✅ Matched file: ${possibleFilename}`);
+              } else {
+                logger.warn(
+                  `⚠️ Could not match uploaded file with any known filename: ${JSON.stringify(uploadedFile)}`,
+                );
+              }
+            });
+
+            // If no individual files matched but API indicates success, use fallback
+            if (
+              successfulFileIds.length === 0 &&
+              apiResult.uploaded.length > 0
+            ) {
+              logger.warn(
+                `🔄 Fallback: No individual file matches found, but API indicates ${apiResult.uploaded.length} uploads. Marking all ${validFiles.length} batch files as uploaded.`,
+              );
+              validFiles.forEach((f) => successfulFileIds.push(f.dbRecord.id));
+            }
+
+            if (successfulFileIds.length > 0) {
+              await supabase
+                .from('uploader')
+                .update({
+                  status: 'file-uploaded',
+                  message: 'Successfully uploaded to Arela API (batch)',
+                })
+                .in('id', successfulFileIds);
+
+              uploaded += successfulFileIds.length;
+              logger.info(
+                `✅ Batch upload successful: ${successfulFileIds.length} files uploaded`,
+              );
+            }
+          }
+
+          // Handle failed files
+          if (apiResult.errors && apiResult.errors.length > 0) {
+            const failedFileIds = [];
+
+            apiResult.errors.forEach((errorInfo) => {
+              // Try multiple possible property names for filename in errors
+              const possibleFilename =
+                errorInfo.fileName ||
+                errorInfo.filename ||
+                errorInfo.name ||
+                errorInfo.file_name ||
+                errorInfo.originalName ||
+                errorInfo.original_name;
+
+              const dbRecord = fileNameToRecord.get(possibleFilename);
+              if (dbRecord) {
+                failedFileIds.push(dbRecord.id);
+              } else {
+                logger.warn(
+                  `⚠️ Could not match error file: ${JSON.stringify(errorInfo)}`,
+                );
+              }
+            });
+
+            if (failedFileIds.length > 0) {
+              await supabase
+                .from('uploader')
+                .update({
+                  status: 'upload-error',
+                  message: `Upload failed: ${apiResult.errors[0].error}`,
+                })
+                .in('id', failedFileIds);
+
+              errors += failedFileIds.length;
+              logger.error(
+                `❌ Batch upload errors: ${failedFileIds.length} files failed`,
+              );
+            }
+          }
+
+          // Handle any remaining files that weren't in uploaded or errors arrays
+          // Use robust filename extraction for both uploaded and error files
+          const extractFilename = (fileObj) => {
+            return (
+              fileObj.fileName ||
+              fileObj.filename ||
+              fileObj.name ||
+              fileObj.file_name ||
+              fileObj.originalName ||
+              fileObj.original_name
+            );
+          };
+
+          const processedFileNames = new Set([
+            ...(apiResult.uploaded || []).map(extractFilename).filter(Boolean),
+            ...(apiResult.errors || []).map(extractFilename).filter(Boolean),
+          ]);
+
+          const unprocessedFiles = validFiles.filter(
+            (f) => !processedFileNames.has(f.fileData.name),
           );
+          if (unprocessedFiles.length > 0) {
+            // Only mark as unprocessed if we haven't already handled all files through fallback logic
+            // If we used fallback (all files marked as uploaded), don't mark any as unprocessed
+            const alreadyHandledCount = uploaded + errors;
+            const shouldMarkUnprocessed =
+              alreadyHandledCount < validFiles.length;
+
+            if (shouldMarkUnprocessed) {
+              const unprocessedIds = unprocessedFiles.map((f) => f.dbRecord.id);
+              await supabase
+                .from('uploader')
+                .update({
+                  status: 'upload-error',
+                  message: 'File not found in API response',
+                })
+                .in('id', unprocessedIds);
+
+              errors += unprocessedIds.length;
+              logger.warn(
+                `⚠️ Unprocessed files: ${unprocessedIds.length} files not found in API response`,
+              );
+              logger.debug(
+                `🔍 API response uploaded array: ${JSON.stringify(apiResult.uploaded)}`,
+              );
+              logger.debug(
+                `🔍 Expected filenames: ${validFiles.map((f) => f.fileData.name).join(', ')}`,
+              );
+            } else {
+              logger.debug(
+                `✅ All files already handled (uploaded: ${uploaded}, errors: ${errors}), skipping unprocessed marking`,
+              );
+            }
+          }
         } else {
-          // Update all files as failed
+          // Complete batch failure - mark all files as failed
           const fileIds = validFiles.map((f) => f.dbRecord.id);
           await supabase
             .from('uploader')
@@ -1363,7 +1680,7 @@ export class DatabaseService {
 
           errors += validFiles.length;
           logger.error(
-            `❌ Batch upload failed: ${validFiles.length} files - ${uploadResult.error}`,
+            `❌ Complete batch failure: ${validFiles.length} files - ${uploadResult.error}`,
           );
         }
       }

package/src/services/upload/ApiUploadService.js

@@ -134,8 +134,16 @@ export class ApiUploadService extends BaseUploadService {
 
       const result = await response.json();
 
+      // Determine if the operation was successful
+      // Success means at least one file was uploaded successfully, even if some failed
+      const hasUploads = result.uploaded && result.uploaded.length > 0;
+      const hasErrors = result.errors && result.errors.length > 0;
+      // Consider it a success if there are uploads, or if there are no errors at all
+      const success =
+        hasUploads || (!hasErrors && result.stats?.totalFiles > 0);
+
       // Normalize response format to match DatabaseService expectations
-      return { success: true, data: result };
+      return { success, data: result };
     } catch (fetchError) {
       // Return normalized error format
       return { success: false, error: fetchError.message };

package/src/services/upload/SupabaseUploadService.js

@@ -88,10 +88,10 @@ export class SupabaseUploadService extends BaseUploadService {
       });
 
     if (error) {
-      throw new Error(error.message);
+      return { success: false, error: error.message };
     }
 
-    return data;
+    return { success: true, data };
   }
 
   /**