@arela/uploader 0.2.12 → 0.3.0

package/src/config/config.js

@@ -16,6 +16,7 @@ class Config {
     this.upload = this.#loadUploadConfig();
     this.performance = this.#loadPerformanceConfig();
     this.logging = this.#loadLoggingConfig();
+    this.watch = this.#loadWatchConfig();
   }
 
   /**
@@ -114,6 +115,58 @@ class Config {
     };
   }
 
+  /**
+   * Load watch configuration
+   * @private
+   */
+  #loadWatchConfig() {
+    // Parse directory configs from JSON format
+    let directoryConfigs = {};
+    if (process.env.WATCH_DIRECTORY_CONFIGS) {
+      try {
+        directoryConfigs = JSON.parse(process.env.WATCH_DIRECTORY_CONFIGS);
+      } catch (error) {
+        console.warn(
+          '⚠️ Invalid JSON in WATCH_DIRECTORY_CONFIGS, using empty config',
+        );
+        directoryConfigs = {};
+      }
+    }
+
+    // Fallback to WATCH_DIRECTORIES for backward compatibility
+    let directories = [];
+    if (
+      Object.keys(directoryConfigs).length === 0 &&
+      process.env.WATCH_DIRECTORIES
+    ) {
+      directories = process.env.WATCH_DIRECTORIES.split(',')
+        .map((d) => d.trim())
+        .filter(Boolean);
+    }
+
+    // Parse ignore patterns
+    const ignorePatterns =
+      process.env.WATCH_IGNORE_PATTERNS?.split(',')
+        .map((p) => p.trim())
+        .filter(Boolean) || [];
+
+    return {
+      enabled: process.env.WATCH_ENABLED === 'true' || false,
+      directories,
+      directoryConfigs,
+      strategy: process.env.WATCH_STRATEGY || 'batch',
+      debounceMs: parseInt(process.env.WATCH_DEBOUNCE_MS) || 1000,
+      batchSize: parseInt(process.env.WATCH_BATCH_SIZE) || 10,
+      usePolling: process.env.WATCH_USE_POLLING === 'true' || false,
+      pollInterval: parseInt(process.env.WATCH_POLL_INTERVAL) || 100,
+      stabilityThreshold:
+        parseInt(process.env.WATCH_STABILITY_THRESHOLD) || 300,
+      ignorePatterns,
+      autoDetect: process.env.WATCH_AUTO_DETECT === 'true' || false,
+      autoOrganize: process.env.WATCH_AUTO_ORGANIZE === 'true' || false,
+    };
+  }
+
   /**
    * Check if API mode is available
    * @returns {boolean}
@@ -181,6 +234,66 @@ class Config {
     }
     return this.upload.basePath;
   }
+
+  /**
+   * Get watch directories with validation
+   * @param {string[]} cliDirs - Directories from CLI options
+   * @returns {string[]} Validated watch directories
+   * @throws {Error} If no directories are configured
+   */
+  getWatchDirectories(cliDirs = null) {
+    // CLI options take precedence over environment variables
+    const directories =
+      cliDirs && cliDirs.length > 0 ? cliDirs : this.watch.directories;
+
+    if (!directories || directories.length === 0) {
+      throw new Error(
+        '⚠️ No watch directories configured. Please use --directories option or set WATCH_DIRECTORIES environment variable.',
+      );
+    }
+
+    return directories;
+  }
+
+  /**
+   * Get watch configuration with validation
+   * @returns {Object} Watch configuration object
+   */
+  getWatchConfig() {
+    return {
+      ...this.watch,
+    };
+  }
+
+  /**
+   * Validate watch configuration
+   * @param {string[]} directories - Directories to validate
+   * @throws {Error} If configuration is invalid
+   */
+  validateWatchConfig(directories) {
+    if (!directories || directories.length === 0) {
+      throw new Error(
+        'At least one directory must be specified for watch mode',
+      );
+    }
+
+    // Validate strategy
+    const validStrategies = ['individual', 'batch', 'full-structure'];
+    if (!validStrategies.includes(this.watch.strategy)) {
+      throw new Error(
+        `Invalid watch strategy: ${this.watch.strategy}. Must be one of: ${validStrategies.join(', ')}`,
+      );
+    }
+
+    // Validate debounce and batch size
+    if (this.watch.debounceMs < 0) {
+      throw new Error('Debounce time must be >= 0');
+    }
+
+    if (this.watch.batchSize < 1) {
+      throw new Error('Batch size must be >= 1');
+    }
+  }
 }
 
 // Export singleton instance

package/src/document-type-shared.js

@@ -1,5 +1,6 @@
 // Import all document type definitions
 import { pedimentoSimplificadoDefinition } from './document-types/pedimento-simplificado.js';
+import { supportDocumentDefinition } from './document-types/support-document.js';
 
 // Document type definitions and extraction utilities
 // Ported from TypeScript to JavaScript for Node.js
@@ -33,6 +34,7 @@ export class DocumentTypeDefinition {
 // Registry of all document types
 const documentTypes = [
   pedimentoSimplificadoDefinition,
+  supportDocumentDefinition,
   // Add more document types here as needed
 ];
 

package/src/document-types/support-document.js

@@ -0,0 +1,201 @@
+import { FieldResult } from '../document-type-shared.js';
+
+/**
+ * Support Document Definition
+ * Detects XML and other supporting documents related to customs operations
+ * These documents are typically metadata or supporting files that accompany pedimento simplificado
+ */
+export const supportDocumentDefinition = {
+  type: 'support_document',
+  extensions: ['xml', 'txt', 'json'],
+  match: (source) => {
+    // Detect SOAP/XML structures common in customs systems
+    const soapClues = [
+      /soapenv:Envelope/i,
+      /xmlns:soapenv=/i,
+      /solicitarRecibirCoveServicio/i,
+      /tipoOperacion/i,
+      /patenteAduanal/i,
+    ];
+
+    // Detect customs-related metadata
+    const customsClues = [
+      /rfc|RFC/,
+      /patente|aduana|customs|pedimento/i,
+    ];
+
+    const soapFound = soapClues.filter((clue) => clue.test(source)).length;
+    const customsFound = customsClues.filter((clue) => clue.test(source)).length;
+
+    // Must have SOAP structure OR customs metadata
+    return soapFound >= 2 || customsFound >= 2;
+  },
+
+  extractNumPedimento: (source, fields) => {
+    // Try to extract pedimento from various XML/text formats
+    const patterns = [
+      // SOAP format with tipoOperacion
+      /tipoOperacion[^>]*>([A-Z]{4}[^<]*)<\/oxml:tipoOperacion/i,
+      // Pedimento number in XML
+      /numPedimento[^>]*>(\d{15})<\/\w+:numPedimento/i,
+      // Generic pattern
+      /pedimento[:\s]*(\d{15})/i,
+    ];
+
+    for (const pattern of patterns) {
+      const match = source.match(pattern);
+      if (match) {
+        return match[1];
+      }
+    }
+
+    return null;
+  },
+
+  extractPedimentoYear: (source, fields) => {
+    const numPedimento = fields?.find((f) => f.name === 'numPedimento')?.value;
+    if (!numPedimento) {
+      // Try to extract year from date in XML
+      const dateMatch = source.match(/(\d{4})-\d{2}-\d{2}/);
+      if (dateMatch) {
+        return parseInt(dateMatch[1], 10);
+      }
+      return null;
+    }
+
+    const year = parseInt(numPedimento.substring(0, 2), 10);
+    return year < 50 ? year + 2000 : year + 1900;
+  },
+
+  extractors: [
+    // RFC (Registro Federal de Contribuyentes)
+    {
+      field: 'rfc',
+      extract: (source) => {
+        const patterns = [
+          /rfc[^>]*>([A-ZÑ&]{3,4}\d{6}[A-Z0-9]{3})<\/\w+:rfc/i,
+          /rfcConsulta[^>]*>([A-ZÑ&]{3,4}\d{6}[A-Z0-9]{3})<\/\w+:rfcConsulta/i,
+          /RFC[:\s]*([A-ZÑ&]{3,4}\d{6}[A-Z0-9]{3})/,
+        ];
+
+        for (const pattern of patterns) {
+          const match = source.match(pattern);
+          if (match) {
+            return new FieldResult('rfc', true, match[1]);
+          }
+        }
+
+        return new FieldResult('rfc', false, null);
+      },
+    },
+
+    // Patente Aduanal
+    {
+      field: 'patente',
+      extract: (source) => {
+        const patterns = [
+          /patenteAduanal[^>]*>(\d{4})<\/\w+:patenteAduanal/i,
+          /patente[:\s]*(\d{4})/i,
+        ];
+
+        for (const pattern of patterns) {
+          const match = source.match(pattern);
+          if (match) {
+            return new FieldResult('patente', true, match[1]);
+          }
+        }
+
+        return new FieldResult('patente', false, null);
+      },
+    },
+
+    // Aduana
+    {
+      field: 'aduanaEntradaSalida',
+      extract: (source) => {
+        const patterns = [
+          /aduanaEntradaSalida[^>]*>(\d{1,2})<\/\w+:aduanaEntradaSalida/i,
+          /aduana[:\s]*(\d{1,2})/i,
+        ];
+
+        for (const pattern of patterns) {
+          const match = source.match(pattern);
+          if (match) {
+            return new FieldResult('aduanaEntradaSalida', true, match[1]);
+          }
+        }
+
+        return new FieldResult('aduanaEntradaSalida', false, null);
+      },
+    },
+
+    // Pedimento Number
+    {
+      field: 'numPedimento',
+      extract: (source) => {
+        const patterns = [
+          /numPedimento[^>]*>(\d{15})<\/\w+:numPedimento/i,
+          /pedimento[:\s]*(\d{15})/i,
+        ];
+
+        for (const pattern of patterns) {
+          const match = source.match(pattern);
+          if (match) {
+            return new FieldResult('numPedimento', true, match[1]);
+          }
+        }
+
+        return new FieldResult('numPedimento', false, null);
+      },
+    },
+
+    // Email/Contact
+    {
+      field: 'email',
+      extract: (source) => {
+        const match = source.match(/[\w.-]+@[\w.-]+\.\w+/);
+        return new FieldResult('email', !!match, match ? match[0] : null);
+      },
+    },
+
+    // Type of Operation
+    {
+      field: 'tipoOperacion',
+      extract: (source) => {
+        const patterns = [
+          /tipoOperacion[^>]*>([A-Z]{4}[^<]*)<\/\w+:tipoOperacion/i,
+          /tipoOperacion[:\s]*([A-Z]{4})/i,
+        ];
+
+        for (const pattern of patterns) {
+          const match = source.match(pattern);
+          if (match) {
+            return new FieldResult('tipoOperacion', true, match[1]);
+          }
+        }
+
+        return new FieldResult('tipoOperacion', false, null);
+      },
+    },
+
+    // Document Date
+    {
+      field: 'documentDate',
+      extract: (source) => {
+        const patterns = [
+          /fechaExpedicion[^>]*>(\d{4}-\d{2}-\d{2})<\/\w+:fechaExpedicion/i,
+          /fecha[:\s]*(\d{4}-\d{2}-\d{2})/i,
+        ];
+
+        for (const pattern of patterns) {
+          const match = source.match(pattern);
+          if (match) {
+            return new FieldResult('documentDate', true, match[1]);
+          }
+        }
+
+        return new FieldResult('documentDate', false, null);
+      },
+    },
+  ],
+};

package/src/file-detection.js

@@ -191,7 +191,8 @@ export class FileDetectionService {
    */
   isSupportedFileType(filePath) {
     const fileExtension = path.extname(filePath).toLowerCase().replace('.', '');
-    const supportedExtensions = ['pdf'];
+    // Support PDF (main documents), XML (metadata/supporting docs), and TXT
+    const supportedExtensions = ['pdf', 'xml', 'txt'];
     return supportedExtensions.includes(fileExtension);
   }
 

package/src/index.js

@@ -2,6 +2,7 @@
 import { Command } from 'commander';
 
 import UploadCommand from './commands/UploadCommand.js';
+import watchCommand from './commands/WatchCommand.js';
 import appConfig from './config/config.js';
 import ErrorHandler from './errors/ErrorHandler.js';
 import logger from './services/LoggingService.js';
@@ -15,6 +16,7 @@ class ArelaUploaderCLI {
     this.program = new Command();
     this.errorHandler = new ErrorHandler(logger);
     this.uploadCommand = new UploadCommand();
+    this.watchCommand = watchCommand;
 
     this.#setupProgram();
     this.#setupCommands();
@@ -229,6 +231,48 @@ class ArelaUploaderCLI {
         }
       });
 
+    // Watch command
+    this.program
+      .command('watch')
+      .description(
+        'Monitor directories for file changes and upload automatically',
+      )
+      .option(
+        '-d, --directories <paths>',
+        'Comma-separated directories to watch',
+      )
+      .option(
+        '-s, --strategy <strategy>',
+        'Upload strategy: individual|batch|full-structure',
+        'batch',
+      )
+      .option('--debounce <ms>', 'Debounce delay in milliseconds', '1000')
+      .option(
+        '-b, --batch-size <size>',
+        'Number of files to process in each batch',
+        '10',
+      )
+      .option(
+        '--poll <ms>',
+        'Use polling instead of native file system events (interval in ms)',
+      )
+      .option('--ignore <patterns>', 'Comma-separated patterns to ignore')
+      .option('--auto-detect', 'Enable automatic document type detection')
+      .option('--auto-organize', 'Enable automatic file organization')
+      .option(
+        '--auto-processing',
+        'Enable automatic 4-step pipeline (stats, detect, propagate, upload)',
+      )
+      .option('--dry-run', 'Simulate changes without uploading')
+      .option('--verbose', 'Enable verbose logging')
+      .action(async (options) => {
+        try {
+          await this.watchCommand.execute(options);
+        } catch (error) {
+          this.errorHandler.handleFatalError(error, { command: 'watch' });
+        }
+      });
+
     // Version command (already handled by program.version())
 
     // Help command