@arela/uploader 0.2.13 → 1.0.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();
   }
 
   /**
@@ -49,15 +50,168 @@ class Config {
 
   /**
    * Load API configuration
+   * Supports 3 API targets: default, agencia, cliente
+   * Configure ARELA_API_CLIENTE_URL/TOKEN for the specific client you want to use
    * @private
    */
   #loadApiConfig() {
     return {
+      // Default/legacy API (backward compatible)
       baseUrl: process.env.ARELA_API_URL,
       token: process.env.ARELA_API_TOKEN,
+      // Multi-tenant API targets (only 3 options)
+      targets: {
+        agencia: {
+          baseUrl:
+            process.env.ARELA_API_AGENCIA_URL || process.env.ARELA_API_URL,
+          token:
+            process.env.ARELA_API_AGENCIA_TOKEN || process.env.ARELA_API_TOKEN,
+        },
+        cliente: {
+          baseUrl:
+            process.env.ARELA_API_CLIENTE_URL || process.env.ARELA_API_URL,
+          token:
+            process.env.ARELA_API_CLIENTE_TOKEN || process.env.ARELA_API_TOKEN,
+        },
+      },
+      // Current active target (can be changed at runtime)
+      activeTarget: process.env.ARELA_API_TARGET || 'default',
     };
   }
 
+  /**
+   * Get API configuration for a specific target
+   * @param {string} target - API target: 'agencia', 'cliente', or 'default'
+   * @returns {Object} API configuration with baseUrl and token
+   */
+  getApiConfig(target = null) {
+    const targetName = target || this.api.activeTarget || 'default';
+
+    if (targetName === 'default') {
+      return {
+        baseUrl: this.api.baseUrl,
+        token: this.api.token,
+      };
+    }
+
+    const targetConfig = this.api.targets[targetName];
+    if (!targetConfig) {
+      console.warn(
+        `⚠️ Unknown API target '${targetName}', falling back to default`,
+      );
+      return {
+        baseUrl: this.api.baseUrl,
+        token: this.api.token,
+      };
+    }
+
+    return targetConfig;
+  }
+
+  /**
+   * Set the active API target at runtime
+   * @param {string} target - API target: 'default', 'agencia', or 'cliente'
+   */
+  setApiTarget(target) {
+    const validTargets = ['default', 'agencia', 'cliente'];
+    if (!validTargets.includes(target.toLowerCase())) {
+      throw new Error(
+        `Invalid API target '${target}'. Must be one of: ${validTargets.join(', ')}`,
+      );
+    }
+    this.api.activeTarget = target.toLowerCase();
+    const config = this.getApiConfig(target.toLowerCase());
+    console.log(`🎯 API target set to: ${target} → ${config.baseUrl}`);
+  }
+
+  /**
+   * Set source and target APIs for cross-tenant operations
+   * @param {string} sourceTarget - Source API target (for reading data)
+   * @param {string} targetTarget - Target API target (for writing data)
+   */
+  setCrossTenantTargets(sourceTarget, targetTarget) {
+    const validTargets = ['default', 'agencia', 'cliente'];
+
+    if (!validTargets.includes(sourceTarget.toLowerCase())) {
+      throw new Error(
+        `Invalid source API target '${sourceTarget}'. Must be one of: ${validTargets.join(', ')}`,
+      );
+    }
+    if (!validTargets.includes(targetTarget.toLowerCase())) {
+      throw new Error(
+        `Invalid target API target '${targetTarget}'. Must be one of: ${validTargets.join(', ')}`,
+      );
+    }
+
+    this.api.sourceTarget = sourceTarget.toLowerCase();
+    this.api.targetTarget = targetTarget.toLowerCase();
+
+    const sourceConfig = this.getApiConfig(sourceTarget.toLowerCase());
+    const targetConfig = this.getApiConfig(targetTarget.toLowerCase());
+
+    console.log(`🔗 Cross-tenant mode enabled:`);
+    console.log(
+      `   📖 Source (read): ${sourceTarget} → ${sourceConfig.baseUrl}`,
+    );
+    console.log(
+      `   📝 Target (write): ${targetTarget} → ${targetConfig.baseUrl}`,
+    );
+  }
+
+  /**
+   * Get source API config for cross-tenant operations
+   * @returns {Object} Source API configuration
+   */
+  getSourceApiConfig() {
+    if (this.api.sourceTarget) {
+      return this.getApiConfig(this.api.sourceTarget);
+    }
+    return this.getApiConfig();
+  }
+
+  /**
+   * Get target API config for cross-tenant operations
+   * @returns {Object} Target API configuration
+   */
+  getTargetApiConfig() {
+    if (this.api.targetTarget) {
+      return this.getApiConfig(this.api.targetTarget);
+    }
+    return this.getApiConfig();
+  }
+
+  /**
+   * Check if cross-tenant mode is enabled
+   * @returns {boolean}
+   */
+  isCrossTenantMode() {
+    return !!(
+      this.api.sourceTarget &&
+      this.api.targetTarget &&
+      this.api.sourceTarget !== this.api.targetTarget
+    );
+  }
+
+  /**
+   * Get API target by RFC
+   * @param {string} rfc - The RFC to find API target for
+   * @returns {string|null} The API target name or null if not found
+   */
+  getApiTargetByRfc(rfc) {
+    if (!rfc) return null;
+
+    const normalizedRfc = rfc.toUpperCase();
+    for (const [targetName, targetConfig] of Object.entries(this.api.targets)) {
+      if (
+        targetConfig.rfc &&
+        targetConfig.rfc.toUpperCase() === normalizedRfc
+      ) {
+        return targetName;
+      }
+    }
+    return null;
+  }
+
   /**
    * Load upload configuration
    * @private
@@ -114,12 +268,66 @@ 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
+   * @param {string} target - Optional API target to check
    * @returns {boolean}
    */
-  isApiModeAvailable() {
-    return !!(this.api.baseUrl && this.api.token);
+  isApiModeAvailable(target = null) {
+    const config = this.getApiConfig(target);
+    return !!(config.baseUrl && config.token);
   }
 
   /**
@@ -181,6 +389,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,200 @@
+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

@@ -89,6 +89,7 @@ export class FileDetectionService {
             fields: [],
             detectedPedimento: null,
             detectedPedimentoYear: null,
+            rfc: null,
             arelaPath: null,
             text: '',
             error: `Unsupported file type: ${fileExtension}`,
@@ -102,6 +103,7 @@ export class FileDetectionService {
           fields: [],
           detectedPedimento: null,
           detectedPedimentoYear: null,
+          rfc: null,
           arelaPath: null,
           text: '',
           error: 'No text could be extracted from file',
@@ -112,6 +114,9 @@ export class FileDetectionService {
       const [detectedType, fields, detectedPedimento, detectedPedimentoYear] =
         extractDocumentFields(text, fileExtension, filePath);
 
+      // Extract RFC from fields
+      const rfc = fields?.find((f) => f.name === 'rfc')?.value ?? null;
+
       // Compose arela_path for pedimento_simplificado documents
       const arelaPath = composeArelaPath(
         detectedType,
@@ -125,6 +130,7 @@ export class FileDetectionService {
         fields,
         detectedPedimento,
         detectedPedimentoYear,
+        rfc,
         arelaPath,
         text,
         error: null,
@@ -135,6 +141,7 @@ export class FileDetectionService {
         detectedType: null,
         fields: [],
         detectedPedimento: null,
+        rfc: null,
         detectedPedimentoYear: null,
         arelaPath: null,
         text: '',
@@ -191,7 +198,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);
   }