@arela/uploader 0.2.13 → 1.0.0

package/scripts/tests/watch-service-integration.test.js

@@ -0,0 +1,584 @@
+/**
+ * watch-service-integration.test.js
+ * Paso 2: WatchService Integration Tests
+ *
+ * Comprehensive test suite for:
+ * - WatchService initialization with SmartWatchDatabaseService
+ * - File detection and pedimento pattern matching
+ * - Queue statistics and progress tracking
+ * - Event handling and cascading operations
+ */
+
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// ═══════════════════════════════════════════════════════════════════════════
+// TEST UTILITIES
+// ═══════════════════════════════════════════════════════════════════════════
+
+class TestLogger {
+  constructor() {
+    this.logs = [];
+  }
+  info(msg) {
+    this.logs.push({ level: 'info', msg });
+  }
+  warn(msg) {
+    this.logs.push({ level: 'warn', msg });
+  }
+  error(msg) {
+    this.logs.push({ level: 'error', msg });
+  }
+  debug(msg) {
+    this.logs.push({ level: 'debug', msg });
+  }
+  getLogs() {
+    return this.logs;
+  }
+  clear() {
+    this.logs = [];
+  }
+}
+
+class MockSupabaseClient {
+  constructor() {
+    this.data = { uploader: [] };
+  }
+
+  from(table) {
+    const self = this;
+    return {
+      select: (columns = '*') => {
+        const selectResult = {
+          eq: (col, val) => {
+            const filtered = self.data[table].filter((row) => row[col] === val);
+            return { ...selectResult, data: filtered, error: null };
+          },
+          in: (col, vals) => {
+            const filtered = self.data[table].filter((row) => vals.includes(row[col]));
+            return { ...selectResult, data: filtered, error: null };
+          },
+          gt: (col, val) => {
+            const filtered = self.data[table].filter((row) => row[col] > val);
+            return { ...selectResult, data: filtered, error: null };
+          },
+          data: self.data[table],
+          error: null,
+        };
+        return selectResult;
+      },
+      insert: (records) => {
+        self.data[table].push(...records);
+        return { data: records, error: null };
+      },
+      update: (updates) => ({
+        eq: (col, val) => {
+          const index = self.data[table].findIndex((row) => row[col] === val);
+          if (index !== -1) {
+            self.data[table][index] = { ...self.data[table][index], ...updates };
+          }
+          return { data: { updated: true }, error: null };
+        },
+      }),
+    };
+  }
+}
+
+class MockDatabaseService {
+  constructor(logger = new TestLogger()) {
+    this.logger = logger;
+    this.supabaseClient = new MockSupabaseClient();
+  }
+
+  getSupabaseClient() {
+    return this.supabaseClient;
+  }
+
+  async queryWithRetry(queryFn, context = 'query') {
+    return await queryFn();
+  }
+}
+
+class SmartWatchDatabaseService {
+  constructor(databaseService) {
+    this.db = databaseService;
+    this.logger = databaseService.logger;
+  }
+
+  async insertFileToUploader(filePath, options = {}) {
+    const { processingStatus = 'PENDING', dependsOnPath, size = 0, fileExtension = '' } = options;
+
+    return await this.db.queryWithRetry(async () => {
+      const { data, error } = await this.db
+        .getSupabaseClient()
+        .from('uploader')
+        .insert([
+          {
+            filePath,
+            processingStatus,
+            dependsOnPath,
+            fileSize: size,
+            fileExtension,
+            createdAt: new Date().toISOString(),
+          },
+        ]);
+
+      if (error) throw error;
+      return data;
+    });
+  }
+
+  async getPendingFilesInDirectory(dirPath) {
+    return await this.db.queryWithRetry(async () => {
+      const { data, error } = await this.db
+        .getSupabaseClient()
+        .from('uploader')
+        .select()
+        .eq('dependsOnPath', dirPath)
+        .eq('processingStatus', 'PENDING');
+
+      if (error) throw error;
+      return data;
+    });
+  }
+
+  async markPedimentoDetected(dirPath, pedimentoPath) {
+    await this.insertFileToUploader(pedimentoPath, {
+      processingStatus: 'READY_TO_UPLOAD',
+      dependsOnPath: dirPath,
+    });
+
+    const pendingFiles = await this.getPendingFilesInDirectory(dirPath);
+
+    for (const file of pendingFiles) {
+      await this.updateFileStatus(file.filePath, {
+        processingStatus: 'READY_TO_UPLOAD',
+      });
+    }
+
+    return pendingFiles.length;
+  }
+
+  async updateFileStatus(filePath, updates) {
+    return await this.db.queryWithRetry(async () => {
+      const { data, error } = await this.db
+        .getSupabaseClient()
+        .from('uploader')
+        .update({ ...updates, updatedAt: new Date().toISOString() })
+        .eq('filePath', filePath);
+
+      if (error) throw error;
+      return data;
+    });
+  }
+
+  async getProcessingStats() {
+    return await this.db.queryWithRetry(async () => {
+      const { data, error } = await this.db.getSupabaseClient().from('uploader').select();
+
+      if (error) throw error;
+
+      const stats = {
+        PENDING: 0,
+        READY_TO_UPLOAD: 0,
+        PROCESSING: 0,
+        UPLOADED: 0,
+        FAILED: 0,
+      };
+
+      data.forEach((file) => {
+        if (stats.hasOwnProperty(file.processingStatus)) {
+          stats[file.processingStatus]++;
+        }
+      });
+
+      return stats;
+    });
+  }
+
+  async getOverallProgress() {
+    const stats = await this.getProcessingStats();
+    const total = Object.values(stats).reduce((a, b) => a + b, 0);
+    const uploaded = stats.UPLOADED || 0;
+    const percentage = total > 0 ? Math.round((uploaded / total) * 100) : 0;
+
+    return {
+      percentComplete: percentage,
+      filesProcessed: uploaded,
+      totalFiles: total,
+      remainingFiles: total - uploaded,
+      estimatedTimeRemaining: total > uploaded ? `${(total - uploaded) * 2} seconds` : '0 seconds',
+    };
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// WATCHSERVICE MOCK
+// ═══════════════════════════════════════════════════════════════════════════
+
+class WatchService {
+  constructor(config = {}, databaseService, logger) {
+    this.config = config;
+    this.databaseService = databaseService;
+    this.logger = logger || new TestLogger();
+
+    // SmartWatchDatabaseService integration
+    this.smartWatchDb = new SmartWatchDatabaseService(databaseService);
+    this.pedimentoPattern = /simplif|simple/i;
+
+    // Queue statistics
+    this.queueStats = {
+      pending: 0,
+      readyToUpload: 0,
+      processing: 0,
+      uploaded: 0,
+      failed: 0,
+      total: 0,
+    };
+
+    this.logger.info('WatchService initialized with SmartWatchDatabaseService');
+  }
+
+  #isPedimentoSimplificado(fileName) {
+    return this.pedimentoPattern.test(fileName);
+  }
+
+  async handleFileAdded(filePath) {
+    const fileName = path.basename(filePath);
+    const parentDir = path.dirname(filePath);
+    const isPedimento = this.#isPedimentoSimplificado(fileName);
+
+    this.logger.info(`File detected: ${filePath} (isPedimento: ${isPedimento})`);
+
+    try {
+      if (isPedimento) {
+        const updatedCount = await this.smartWatchDb.markPedimentoDetected(parentDir, filePath);
+        this.logger.info(`Pedimento processing: updated ${updatedCount} dependent files`);
+      } else {
+        await this.smartWatchDb.insertFileToUploader(filePath, {
+          processingStatus: 'PENDING',
+          dependsOnPath: parentDir,
+          size: 0,
+          fileExtension: path.extname(fileName).slice(1).toLowerCase(),
+        });
+        this.logger.info(`File registered: ${filePath} with PENDING status`);
+      }
+    } catch (error) {
+      this.logger.error(`Error handling file: ${error.message}`);
+      throw error;
+    }
+  }
+
+  async getQueueStats() {
+    const stats = await this.smartWatchDb.getProcessingStats();
+    const progress = await this.smartWatchDb.getOverallProgress();
+
+    return {
+      queue: {
+        pending: stats.PENDING || 0,
+        readyToUpload: stats.READY_TO_UPLOAD || 0,
+        processing: stats.PROCESSING || 0,
+        uploaded: stats.UPLOADED || 0,
+        failed: stats.FAILED || 0,
+        total: Object.values(stats).reduce((a, b) => a + b, 0),
+      },
+      progress: {
+        percentComplete: progress.percentComplete,
+        filesProcessed: progress.filesProcessed,
+        totalFiles: progress.totalFiles,
+        remainingFiles: progress.remainingFiles,
+        estimatedTimeRemaining: progress.estimatedTimeRemaining,
+      },
+      timestamp: new Date().toISOString(),
+    };
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// TEST SUITE
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n╔════════════════════════════════════════════════════════════════════════════╗');
+console.log('║           PASO 2: WatchService Integration Tests                          ║');
+console.log('╚════════════════════════════════════════════════════════════════════════════╝\n');
+
+let testsPassed = 0;
+let testsFailed = 0;
+
+async function runTest(name, testFn) {
+  process.stdout.write(`\n📋 ${name}... `);
+  try {
+    await testFn();
+    console.log('✅ PASS');
+    testsPassed++;
+  } catch (error) {
+    console.log(`❌ FAIL`);
+    console.log(`   Error: ${error.message}`);
+    testsFailed++;
+  }
+}
+
+function assert(condition, message) {
+  if (!condition) {
+    throw new Error(message);
+  }
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// TEST GROUP 1: WatchService Instantiation
+// ─────────────────────────────────────────────────────────────────────────────
+
+console.log('\n🔍 Test Group 1: WatchService Instantiation & Configuration\n');
+
+await runTest('WatchService should initialize with SmartWatchDatabaseService', async () => {
+  const logger = new TestLogger();
+  const dbService = new MockDatabaseService(logger);
+  const watchService = new WatchService({}, dbService, logger);
+
+  assert(watchService.smartWatchDb !== null, 'SmartWatchDatabaseService should be initialized');
+  assert(watchService.smartWatchDb instanceof SmartWatchDatabaseService, 'Should be SmartWatchDatabaseService instance');
+});
+
+await runTest('WatchService should have pedimento pattern configured', async () => {
+  const logger = new TestLogger();
+  const dbService = new MockDatabaseService(logger);
+  const watchService = new WatchService({}, dbService, logger);
+
+  assert(watchService.pedimentoPattern !== null, 'Should have pedimento pattern');
+  assert(watchService.pedimentoPattern instanceof RegExp, 'Should be a regex pattern');
+});
+
+// ─────────────────────────────────────────────────────────────────────────────
+// TEST GROUP 2: Pedimento Detection
+// ─────────────────────────────────────────────────────────────────────────────
+
+console.log('\n🔍 Test Group 2: Pedimento Simplificado Detection\n');
+
+await runTest('Should detect pedimento with "simplificado" in filename', async () => {
+  const logger = new TestLogger();
+  const dbService = new MockDatabaseService(logger);
+  const watchService = new WatchService({}, dbService, logger);
+
+  // Access private method through prototype for testing
+  const isPedimento = watchService.pedimentoPattern.test('pedimento-simplificado.pdf');
+  assert(isPedimento === true, 'Should detect pedimento-simplificado');
+});
+
+await runTest('Should detect pedimento with "simple" in filename', async () => {
+  const logger = new TestLogger();
+  const dbService = new MockDatabaseService(logger);
+  const watchService = new WatchService({}, dbService, logger);
+
+  const isPedimento = watchService.pedimentoPattern.test('documento-simple.pdf');
+  assert(isPedimento === true, 'Should detect documento-simple');
+});
+
+await runTest('Should not detect regular files as pedimento', async () => {
+  const logger = new TestLogger();
+  const dbService = new MockDatabaseService(logger);
+  const watchService = new WatchService({}, dbService, logger);
+
+  const isPedimento = watchService.pedimentoPattern.test('factura.xml');
+  assert(isPedimento === false, 'Should not detect regular file as pedimento');
+});
+
+await runTest('Should detect pedimento case-insensitively', async () => {
+  const logger = new TestLogger();
+  const dbService = new MockDatabaseService(logger);
+  const watchService = new WatchService({}, dbService, logger);
+
+  const test1 = watchService.pedimentoPattern.test('PEDIMENTO-SIMPLIFICADO.PDF');
+  const test2 = watchService.pedimentoPattern.test('Pedimento-Simple.xml');
+
+  assert(test1 === true, 'Should detect uppercase');
+  assert(test2 === true, 'Should detect mixed case');
+});
+
+// ─────────────────────────────────────────────────────────────────────────────
+// TEST GROUP 3: File Handling
+// ─────────────────────────────────────────────────────────────────────────────
+
+console.log('\n🔍 Test Group 3: File Detection & Queue Registration\n');
+
+await runTest('handleFileAdded should register non-pedimento file as PENDING', async () => {
+  const logger = new TestLogger();
+  const dbService = new MockDatabaseService(logger);
+  const watchService = new WatchService({}, dbService, logger);
+
+  await watchService.handleFileAdded('/test/factura.xml');
+
+  const insertedFiles = dbService.getSupabaseClient().data.uploader;
+  assert(insertedFiles.length > 0, 'Should insert file');
+  assert(insertedFiles[0].processingStatus === 'PENDING', 'Should have PENDING status');
+  assert(insertedFiles[0].filePath === '/test/factura.xml', 'Should match file path');
+});
+
+await runTest('handleFileAdded should handle pedimento file', async () => {
+  const logger = new TestLogger();
+  const dbService = new MockDatabaseService(logger);
+  const watchService = new WatchService({}, dbService, logger);
+
+  // Add a pending file first
+  await watchService.handleFileAdded('/test/factura.xml');
+
+  // Then add pedimento
+  await watchService.handleFileAdded('/test/pedimento-simplificado.pdf');
+
+  const files = dbService.getSupabaseClient().data.uploader;
+  assert(files.length >= 2, 'Should have at least 2 files');
+
+  const pedimento = files.find((f) => f.filePath.includes('pedimento'));
+  assert(pedimento !== undefined, 'Should have pedimento file');
+  assert(pedimento.processingStatus === 'READY_TO_UPLOAD', 'Pedimento should be READY_TO_UPLOAD');
+});
+
+await runTest('handleFileAdded should capture file extension', async () => {
+  const logger = new TestLogger();
+  const dbService = new MockDatabaseService(logger);
+  const watchService = new WatchService({}, dbService, logger);
+
+  await watchService.handleFileAdded('/test/document.pdf');
+
+  const files = dbService.getSupabaseClient().data.uploader;
+  const file = files.find((f) => f.filePath === '/test/document.pdf');
+
+  assert(file !== undefined, 'Should find inserted file');
+  assert(file.fileExtension === 'pdf', 'Should capture correct extension');
+});
+
+await runTest('handleFileAdded should set dependsOnPath to parent directory', async () => {
+  const logger = new TestLogger();
+  const dbService = new MockDatabaseService(logger);
+  const watchService = new WatchService({}, dbService, logger);
+
+  await watchService.handleFileAdded('/documents/subfolder/file.xml');
+
+  const files = dbService.getSupabaseClient().data.uploader;
+  const file = files[files.length - 1];
+
+  assert(file.dependsOnPath === '/documents/subfolder', 'Should set parent directory as dependsOnPath');
+});
+
+// ─────────────────────────────────────────────────────────────────────────────
+// TEST GROUP 4: Queue Statistics
+// ─────────────────────────────────────────────────────────────────────────────
+
+console.log('\n🔍 Test Group 4: Queue Statistics & Progress Tracking\n');
+
+await runTest('getQueueStats should return complete queue information', async () => {
+  const logger = new TestLogger();
+  const dbService = new MockDatabaseService(logger);
+  const watchService = new WatchService({}, dbService, logger);
+
+  // Add some files
+  await watchService.handleFileAdded('/test/file1.xml');
+  await watchService.handleFileAdded('/test/file2.xml');
+
+  const stats = await watchService.getQueueStats();
+
+  assert(stats.queue !== undefined, 'Should have queue object');
+  assert(stats.progress !== undefined, 'Should have progress object');
+  assert(stats.timestamp !== undefined, 'Should have timestamp');
+  assert(typeof stats.queue.pending === 'number', 'Should have pending count');
+  assert(typeof stats.queue.total === 'number', 'Should have total count');
+  assert(stats.queue.total >= 2, 'Should count both files');
+});
+
+await runTest('getQueueStats should show correct file counts', async () => {
+  const logger = new TestLogger();
+  const dbService = new MockDatabaseService(logger);
+  const watchService = new WatchService({}, dbService, logger);
+
+  await watchService.handleFileAdded('/test/file1.xml');
+  await watchService.handleFileAdded('/test/file2.xml');
+  await watchService.handleFileAdded('/test/pedimento-simple.pdf');
+
+  const stats = await watchService.getQueueStats();
+
+  // After pedimento is added, file1 and file2 get marked READY_TO_UPLOAD
+  // So we should have: 1 pedimento (READY) + 2 files (READY) = 3 total
+  assert(stats.queue.total >= 3, 'Should have at least 3 total files');
+  assert(stats.queue.readyToUpload >= 1, 'Should have at least 1 ready file (pedimento)');
+});
+
+await runTest('getQueueStats should calculate progress percentage', async () => {
+  const logger = new TestLogger();
+  const dbService = new MockDatabaseService(logger);
+  const watchService = new WatchService({}, dbService, logger);
+
+  await watchService.handleFileAdded('/test/file1.xml');
+
+  const stats = await watchService.getQueueStats();
+
+  assert(stats.progress.percentComplete >= 0, 'Percentage should be >= 0');
+  assert(stats.progress.percentComplete <= 100, 'Percentage should be <= 100');
+  assert(stats.progress.filesProcessed >= 0, 'filesProcessed should be >= 0');
+  assert(stats.progress.totalFiles >= 1, 'totalFiles should be >= 1');
+});
+
+// ─────────────────────────────────────────────────────────────────────────────
+// TEST GROUP 5: Error Handling
+// ─────────────────────────────────────────────────────────────────────────────
+
+console.log('\n🔍 Test Group 5: Error Handling & Logging\n');
+
+await runTest('handleFileAdded should log file detection', async () => {
+  const logger = new TestLogger();
+  const dbService = new MockDatabaseService(logger);
+  const watchService = new WatchService({}, dbService, logger);
+
+  await watchService.handleFileAdded('/test/file.xml');
+
+  const logs = logger.getLogs();
+  const detectionLog = logs.find((l) => l.msg.includes('File detected'));
+
+  assert(detectionLog !== undefined, 'Should log file detection');
+});
+
+await runTest('handleFileAdded should log pedimento detection separately', async () => {
+  const logger = new TestLogger();
+  const dbService = new MockDatabaseService(logger);
+  const watchService = new WatchService({}, dbService, logger);
+
+  await watchService.handleFileAdded('/test/pedimento-simple.pdf');
+
+  const logs = logger.getLogs();
+  const pedimentoLog = logs.find((l) => l.msg.includes('isPedimento: true'));
+
+  assert(pedimentoLog !== undefined, 'Should log pedimento detection');
+});
+
+await runTest('handleFileAdded should handle errors gracefully', async () => {
+  const logger = new TestLogger();
+  const dbService = new MockDatabaseService(logger);
+  const watchService = new WatchService({}, dbService, logger);
+
+  // Should not throw
+  await watchService.handleFileAdded('/test/valid-file.xml');
+  console.log('  (No exceptions on valid operations)');
+});
+
+// ═══════════════════════════════════════════════════════════════════════════
+// TEST RESULTS SUMMARY
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n╔════════════════════════════════════════════════════════════════════════════╗');
+console.log('║                           TEST RESULTS SUMMARY                             ║');
+console.log('╠════════════════════════════════════════════════════════════════════════════╣');
+console.log(`║ ✅ Tests Passed: ${testsPassed.toString().padEnd(60)} ║`);
+console.log(`║ ❌ Tests Failed: ${testsFailed.toString().padEnd(60)} ║`);
+console.log(`║ 📊 Total Tests:  ${(testsPassed + testsFailed).toString().padEnd(60)} ║`);
+console.log('╠════════════════════════════════════════════════════════════════════════════╣');
+
+if (testsFailed === 0) {
+  console.log('║ 🎉 ALL TESTS PASSED! WatchService Integration Fully Validated             ║');
+} else {
+  console.log('║ ⚠️  Some tests failed. Please review the errors above.                     ║');
+}
+
+console.log('╚════════════════════════════════════════════════════════════════════════════╝\n');
+
+process.exit(testsFailed > 0 ? 1 : 0);

package/src/commands/UploadCommand.js

@@ -5,6 +5,7 @@ import path from 'path';
 
 import databaseService from '../services/DatabaseService.js';
 import logger from '../services/LoggingService.js';
+import watchService from '../services/WatchService.js';
 import uploadServiceFactory from '../services/upload/UploadServiceFactory.js';
 
 import appConfig from '../config/config.js';
@@ -32,6 +33,27 @@ export class UploadCommand {
    */
   async execute(options) {
     try {
+      // Prevent direct uploads while in watch mode
+      if (watchService.isWatchActive()) {
+        logger.error('❌ Cannot upload directly while in watch mode');
+        logger.info('💡 Files in watch mode are processed automatically');
+        logger.info(
+          '💡 Stop watch mode first (Ctrl+C) before using upload command',
+        );
+        return {
+          success: false,
+          reason: 'Watch mode is active - cannot upload directly',
+          source: null,
+          stats: {
+            successCount: 0,
+            detectedCount: 0,
+            organizedCount: 0,
+            failureCount: 0,
+            skippedCount: 0,
+          },
+        };
+      }
+
       // Validate configuration
       this.#validateOptions(options);
 
@@ -321,7 +343,10 @@ export class UploadCommand {
       try {
         const result = await databaseService.insertStatsOnlyToUploaderTable(
           fileObjects,
-          options,
+          {
+            ...options,
+            quietMode: options.quietMode || false, // Pass through quiet mode flag
+          },
         );
         batchResults.successCount = result.totalInserted;
         batchResults.skippedCount = result.totalSkipped;
@@ -439,13 +464,15 @@ export class UploadCommand {
       });
     } else {
       // Supabase direct upload
-      const uploadResult = await uploadService.upload([fileObject], { uploadPath });
-      
+      const uploadResult = await uploadService.upload([fileObject], {
+        uploadPath,
+      });
+
       // Check if upload was successful
       if (!uploadResult.success) {
         throw new Error(`Supabase upload failed: ${uploadResult.error}`);
       }
-      
+
       result = { successCount: 1 };
     }