@arela/uploader 1.0.20 → 1.0.22

package/src/commands/IdentifyCommand.js

@@ -9,6 +9,24 @@ import ErrorHandler from '../errors/ErrorHandler.js';
 import { ConfigurationError } from '../errors/ErrorTypes.js';
 import FileDetectionService from '../file-detection.js';
 
+/**
+ * Paid pedimento detected_type values. `pedimento_completo_xml` is included
+ * even though the XML matcher is currently disabled in the registry so that
+ * re-enabling it requires no changes here.
+ */
+const DETECTED_PEDIMENTO_TYPES = new Set([
+  'pedimento_simplificado',
+  'pedimento_completo',
+  'pedimento_completo_xml',
+]);
+
+/** Unpaid pedimento detected_type values (proforma variants). */
+const PROFORMA_TYPES = new Set([
+  'proforma',
+  'proforma_completo',
+  'proforma_completo_xml',
+]);
+
 /**
  * Identify Command Handler
  * Optimized replacement for "detect --detect-pdfs"
@@ -56,29 +74,95 @@ export class IdentifyCommand {
       const scanConfig = appConfig.getScanConfig();
       const batchSize = parseInt(options.batchSize) || 100;
 
+      // Parse optional path prefix mapping: "O:/=/Volumes/nas/"
+      const pathPrefixMap = options.pathPrefix
+        ? this.#parsePathPrefix(options.pathPrefix)
+        : null;
+
       logger.info('🔍 Starting arela identify command');
       logger.info(`🎯 API Target: ${apiTarget}`);
       logger.info(`📦 Batch Size: ${batchSize}`);
+      if (options.table) logger.info(`📌 Target table: ${options.table}`);
+      if (options.resetAttempts)
+        logger.info('♻️  Reset detection attempts: ON');
+      if (pathPrefixMap)
+        logger.info(
+          `🗺  Path prefix map: ${pathPrefixMap.from} → ${pathPrefixMap.to}`,
+        );
 
-      // Fetch all tables for this instance
-      logger.info('\n📊 Fetching instance tables...');
-      const tables = await this.scanApiService.getInstanceTables(
-        scanConfig.companySlug,
-        scanConfig.serverId,
-        scanConfig.basePathFull,
-      );
+      // Resolve the list of tables to process
+      let tables;
+      if (options.fileId && options.table) {
+        // Single-file mode — identify exactly one file record
+        logger.info(
+          `\n🎯 Single-file mode: ${options.table} / ${options.fileId}`,
+        );
+        this.#reportProgress(0, `Fetching file record ${options.fileId}...`);
+        const record = await this.scanApiService.getFileRecord(
+          options.table,
+          options.fileId,
+        );
+        const results = await this.#detectFilesLocally(
+          [record],
+          1,
+          pathPrefixMap,
+        );
+        const updates = results.filter((r) => r !== null);
+        if (updates.length > 0) {
+          await this.scanApiService.batchUpdateDetection(
+            options.table,
+            updates,
+          );
+        }
+        this.#reportProgress(100, `Single-file identification complete`);
+        logger.success(`\n✅ Single-file identification complete`);
+        const firstUpdate = updates[0];
+        return {
+          processed: 1,
+          detected: updates.length,
+          proformas: 0,
+          errors: 1 - updates.length,
+          detectedType: firstUpdate?.detectedType ?? null,
+          detectedPedimento: firstUpdate?.detectedPedimento ?? null,
+          rfc: firstUpdate?.rfc ?? null,
+          arelaPath: firstUpdate?.arelaPath ?? null,
+        };
+      } else if (options.table) {
+        // Single-table mode — no need to match instance tables
+        tables = [{ tableName: options.table }];
+        logger.info(`\n📌 Single-table mode: ${options.table}`);
+      } else {
+        logger.info('\n📊 Fetching instance tables...');
+        tables = await this.scanApiService.getInstanceTables(
+          scanConfig.companySlug,
+          scanConfig.serverId,
+          scanConfig.basePathFull,
+        );
+
+        if (tables.length === 0) {
+          throw new ConfigurationError(
+            'No tables found for this instance. Run "arela scan" first.',
+          );
+        }
 
-      if (tables.length === 0) {
-        throw new ConfigurationError(
-          'No tables found for this instance. Run "arela scan" first.',
+        logger.info(
+          `📋 Found ${tables.length} table${tables.length === 1 ? '' : 's'} to process`,
         );
+        for (const table of tables) {
+          logger.info(`   - ${table.tableName}`);
+        }
       }
 
-      logger.info(
-        `📋 Found ${tables.length} table${tables.length === 1 ? '' : 's'} to process`,
-      );
-      for (const table of tables) {
-        logger.info(`   - ${table.tableName}`);
+      // Optionally reset detection attempts so previously-failed files are retried
+      if (options.resetAttempts) {
+        for (const table of tables) {
+          const { reset } = await this.scanApiService.resetDetectionAttempts(
+            table.tableName,
+          );
+          logger.info(
+            `♻️  Reset ${reset} detection attempt(s) in ${table.tableName}`,
+          );
+        }
       }
 
       // Process each table
@@ -109,6 +193,7 @@ export class IdentifyCommand {
           table.tableName,
           batchSize,
           startTime,
+          pathPrefixMap,
         );
 
         totalStats.processed += stats.processed;
@@ -165,7 +250,7 @@ export class IdentifyCommand {
    * @param {number} startTime - Start time for speed calculation
    * @returns {Promise<Object>} Processing statistics
    */
-  async #processTable(tableName, batchSize, startTime) {
+  async #processTable(tableName, batchSize, startTime, pathPrefixMap = null) {
     // Get detection statistics first (allTypes=true to count all supported file types)
     const initialStats = await this.scanApiService.getDetectionStats(
       tableName,
@@ -237,7 +322,11 @@ export class IdentifyCommand {
       const files = response.data;
 
       // Detect files locally with concurrent processing
-      const detectionResults = await this.#detectFilesLocally(files, 10);
+      const detectionResults = await this.#detectFilesLocally(
+        files,
+        10,
+        pathPrefixMap,
+      );
 
       // Batch update to API
       const updateResult = await this.scanApiService.batchUpdateDetection(
@@ -247,11 +336,13 @@ export class IdentifyCommand {
 
       // Update statistics
       processedCount += files.length;
-      detectedCount += detectionResults.filter(
-        (r) => r.detectedType === 'pedimento_simplificado',
+      // "Detected" counts paid pedimentos of any flavour (simplificado,
+      // completo, completo_xml when enabled).
+      detectedCount += detectionResults.filter((r) =>
+        DETECTED_PEDIMENTO_TYPES.has(r.detectedType),
       ).length;
-      proformaCount += detectionResults.filter(
-        (r) => r.detectedType === 'proforma',
+      proformaCount += detectionResults.filter((r) =>
+        PROFORMA_TYPES.has(r.detectedType),
       ).length;
       errorCount += detectionResults.filter((r) => r.detectionError).length;
 
@@ -281,7 +372,7 @@ export class IdentifyCommand {
    * @param {number} concurrency - Maximum concurrent detections
    * @returns {Promise<Array>} Detection results
    */
-  async #detectFilesLocally(files, concurrency = 10) {
+  async #detectFilesLocally(files, concurrency = 10, pathPrefixMap = null) {
     const limit = pLimit(concurrency);
     const basePath = appConfig.getBasePath();
 
@@ -289,7 +380,17 @@ export class IdentifyCommand {
       limit(async () => {
         try {
           // Check if file exists on filesystem
-          const absolutePath = file.absolute_path;
+          let absolutePath = file.absolute_path;
+
+          // Apply cross-platform path prefix mapping if configured
+          if (
+            pathPrefixMap &&
+            absolutePath &&
+            absolutePath.startsWith(pathPrefixMap.from)
+          ) {
+            absolutePath =
+              pathPrefixMap.to + absolutePath.slice(pathPrefixMap.from.length);
+          }
 
           if (!fs.existsSync(absolutePath)) {
             return {
@@ -324,8 +425,8 @@ export class IdentifyCommand {
           // Detect using existing FileDetectionService
           const result = await this.detectionService.detectFile(absolutePath);
 
-          // If detection succeeded and found a pedimento_simplificado (paid)
-          if (result.detectedType === 'pedimento_simplificado') {
+          // If detection succeeded and found a paid pedimento (any variant)
+          if (DETECTED_PEDIMENTO_TYPES.has(result.detectedType)) {
             return {
               id: file.id,
               detectedType: result.detectedType,
@@ -338,8 +439,8 @@ export class IdentifyCommand {
             };
           }
 
-          // If detection succeeded and found a proforma (unpaid pedimento)
-          if (result.detectedType === 'proforma') {
+          // If detection succeeded and found a proforma (any variant)
+          if (PROFORMA_TYPES.has(result.detectedType)) {
             return {
               id: file.id,
               detectedType: result.detectedType,
@@ -365,7 +466,7 @@ export class IdentifyCommand {
             detectionError = `DETECTION_ERROR: ${result.error}`;
           } else if (isDefinitelyNotPedimento) {
             detectionError =
-              'NOT_PEDIMENTO: File does not match pedimento-simplificado pattern. Missing key markers: "FORMA SIMPLIFICADA DE PEDIMENTO".';
+              'NOT_PEDIMENTO: File does not match any pedimento pattern. Missing key markers (e.g. "FORMA SIMPLIFICADA DE PEDIMENTO" or "NUM. PEDIMENTO:" + copy markers).';
           } else {
             // Partial match - might be a pedimento with missing fields
             const missingFields = this.#getMissingFields(result);
@@ -434,18 +535,23 @@ export class IdentifyCommand {
       return false;
     }
 
-    // If it was detected as a proforma, it's related to a pedimento structure
-    if (result.detectedType === 'proforma') {
+    // If it was detected as a proforma (any variant), it's related to a
+    // pedimento structure — not "definitely not".
+    if (PROFORMA_TYPES.has(result.detectedType)) {
       return false;
     }
 
-    // Check if the text contains the required pedimento marker
-    // This must match the criteria in pedimento-simplificado.js match function
+    // Check if the text contains any required pedimento marker. This must
+    // stay aligned with the `match()` predicates in pedimento-simplificado.js
+    // and pedimento-completo.js.
     const text = result.text || '';
-    const hasRequiredMarker = /FORMA SIMPLIFICADA DE PEDIMENTO/i.test(text);
+    const hasSimplificadoMarker = /FORMA SIMPLIFICADA DE PEDIMENTO/i.test(text);
+    const hasCompletoMarkers =
+      /NUM\.?\s*PEDIMENTO:/i.test(text) &&
+      /CVE\.?\s*PEDIMENTO:/i.test(text) &&
+      /T\.?\s*OPER:/i.test(text);
 
-    // If the required marker is not found, it's definitely not a pedimento
-    return !hasRequiredMarker;
+    return !hasSimplificadoMarker && !hasCompletoMarkers;
   }
 
   /**
@@ -518,6 +624,44 @@ export class IdentifyCommand {
       }
     }
   }
+
+  /**
+   * Parse a path prefix mapping string such as "O:/=/Volumes/nas/" into { from, to }.
+   * Supports both "FROM=TO" and "FROM:TO" separators.
+   * @private
+   * @param {string} mapping
+   * @returns {{ from: string, to: string }}
+   */
+  #parsePathPrefix(mapping) {
+    // Support either "FROM=TO" or "FROM:TO" as separator
+    const eqIdx = mapping.indexOf('=');
+    const colonIdx = mapping.indexOf(':');
+
+    let sep = -1;
+    // "O:/=/Volumes" — the colon inside "O:/" is part of a Windows drive letter; prefer '=' separator
+    if (eqIdx !== -1) {
+      sep = eqIdx;
+    } else if (colonIdx !== -1) {
+      sep = colonIdx;
+    }
+
+    if (sep === -1) {
+      throw new Error(
+        `Invalid --path-prefix format: "${mapping}". Expected "FROM=TO" e.g. "O:/=/Volumes/nas/"`,
+      );
+    }
+
+    const from = mapping.slice(0, sep);
+    const to = mapping.slice(sep + 1);
+
+    if (!from || !to) {
+      throw new Error(
+        `Invalid --path-prefix format: "${mapping}". Both FROM and TO parts must be non-empty.`,
+      );
+    }
+
+    return { from, to };
+  }
 }
 
 // Export singleton instance

package/src/commands/PollWorkerCommand.js

@@ -342,6 +342,8 @@ export class PollWorkerCommand {
       batchSize: 100,
       showStats: false,
       onProgress,
+      ...(job.fileId && { fileId: job.fileId }),
+      ...(job.table && { table: job.table }),
     };
 
     return identifyCommand.execute(options);

package/src/commands/ScanCommand.js

@@ -592,10 +592,13 @@ export class ScanCommand {
     const relativePath = PathNormalizer.getRelativePath(filePath, basePath);
     const absolutePath = PathNormalizer.normalizeSeparators(filePath);
 
-    // Determine if this is potentially a simplificado document
-    // Must be a PDF and filename must contain 'simp' (case-insensitive)
+    // Determine if this file is potentially a pedimento (simplificado, completo, or CoveFact).
+    // PDFs whose filename contains 'simp', 'pedim' or 'covefact' (case-insensitive)
+    // are flagged so the identify stage prioritizes them. The column name
+    // `likely_simplificado` is preserved for backwards compatibility; semantics
+    // are broader (any likely pedimento PDF).
     const likelySimplificado =
-      fileExtension === 'pdf' && fileName.toLowerCase().includes('simp');
+      fileExtension === 'pdf' && /(simp|pedim|covefact)/i.test(fileName);
 
     return {
       fileName,

package/src/config/config.js

@@ -24,6 +24,7 @@ class Config {
     this.watch = this.#loadWatchConfig();
     this.redis = this.#loadRedisConfig();
     this.worker = this.#loadWorkerConfig();
+    this.gdrive = this.#loadGDriveConfig();
   }
 
   /**
@@ -36,10 +37,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 || '1.0.20';
+      return packageJson.version || '1.0.22';
     } catch (error) {
       console.warn('⚠️ Could not read package.json version, using fallback');
-      return '1.0.20';
+      return '1.0.22';
     }
   }
 
@@ -579,6 +580,91 @@ class Config {
     return process.env.ARELA_SERVER_ID || null;
   }
 
+  /**
+   * Load Google Drive sync configuration
+   * @private
+   */
+  #loadGDriveConfig() {
+    const rootFolderId = process.env.GDRIVE_ROOT_FOLDER_ID || null;
+
+    // Default mirror destination: <UPLOAD_BASE_PATH>/_gdrive_mirror
+    let localMirrorPath = process.env.GDRIVE_LOCAL_MIRROR_PATH || null;
+    if (!localMirrorPath && process.env.UPLOAD_BASE_PATH) {
+      const base = process.env.UPLOAD_BASE_PATH;
+      if (base !== '*') {
+        localMirrorPath = path.resolve(
+          PathNormalizer.toAbsolutePath(base),
+          '_gdrive_mirror',
+        );
+      }
+    } else if (localMirrorPath) {
+      localMirrorPath = PathNormalizer.toAbsolutePath(localMirrorPath);
+    }
+
+    return {
+      rootFolderId,
+      localMirrorPath,
+      serviceAccountFile: process.env.GDRIVE_SERVICE_ACCOUNT_FILE || null,
+      serviceAccountJson: process.env.GDRIVE_SERVICE_ACCOUNT_JSON || null,
+      skipNativeDocs: process.env.GDRIVE_SKIP_NATIVE_DOCS !== 'false',
+      followShortcuts: process.env.GDRIVE_FOLLOW_SHORTCUTS !== 'false',
+      concurrency: parseInt(process.env.GDRIVE_CONCURRENCY) || 5,
+      pageSize: parseInt(process.env.GDRIVE_PAGE_SIZE) || 1000,
+      maxFileSizeBytes:
+        parseInt(process.env.GDRIVE_MAX_FILE_SIZE_BYTES) ||
+        2 * 1024 * 1024 * 1024, // 2GB default
+    };
+  }
+
+  /**
+   * Get Google Drive configuration
+   * @returns {Object} GDrive sync settings
+   */
+  getGDriveConfig() {
+    return this.gdrive;
+  }
+
+  /**
+   * Validate Google Drive configuration
+   * @throws {Error} If required gdrive configuration is missing
+   */
+  validateGDriveConfig() {
+    const errors = [];
+
+    if (!this.gdrive.rootFolderId) {
+      errors.push(
+        'GDRIVE_ROOT_FOLDER_ID is required (Drive folder ID to sync)',
+      );
+    }
+
+    if (!this.gdrive.localMirrorPath) {
+      errors.push(
+        'Could not determine local mirror path. Set GDRIVE_LOCAL_MIRROR_PATH or UPLOAD_BASE_PATH',
+      );
+    }
+
+    if (!this.gdrive.serviceAccountFile && !this.gdrive.serviceAccountJson) {
+      errors.push(
+        'Either GDRIVE_SERVICE_ACCOUNT_FILE (path to JSON) or GDRIVE_SERVICE_ACCOUNT_JSON (inline JSON) is required',
+      );
+    }
+
+    if (this.gdrive.serviceAccountFile) {
+      const resolved = PathNormalizer.toAbsolutePath(
+        this.gdrive.serviceAccountFile,
+      );
+      if (!fs.existsSync(resolved)) {
+        errors.push(`GDRIVE_SERVICE_ACCOUNT_FILE not found: ${resolved}`);
+      }
+    }
+
+    if (errors.length > 0) {
+      throw new Error(
+        '⚠️ Google Drive configuration errors:\n   - ' + errors.join('\n   - '),
+      );
+    }
+  }
+
   /**
    * Check if worker mode is available (Redis configured)
    * @returns {boolean}

package/src/document-type-shared.js

@@ -2,6 +2,9 @@
 import { dodaPdfDefinition } from './document-types/doda-pdf.js';
 import { dodaXmlDefinition } from './document-types/doda-xml.js';
 import { facturasComerciales } from './document-types/facturas-comerciales.js';
+import { pedimentoCompletoDefinition } from './document-types/pedimento-completo.js';
+// TODO: enable XML pedimento detection — implementation ready in pedimento-completo-xml.js
+// import { pedimentoCompletoXmlDefinition } from './document-types/pedimento-completo-xml.js';
 import { pedimentoSimplificadoDefinition } from './document-types/pedimento-simplificado.js';
 import { proformaDefinition } from './document-types/proforma.js';
 import { supportDocumentDefinition } from './document-types/support-document.js';
@@ -41,6 +44,12 @@ export class DocumentTypeDefinition {
 // proformaDefinition is kept as reference but not used directly in the registry since resolution is handled post-extraction.
 const documentTypes = [
   pedimentoSimplificadoDefinition,
+  pedimentoCompletoDefinition,
+  // TODO: enable XML pedimento detection — uncomment the next line and the
+  // matching import at the top of this file. All downstream code
+  // (composeArelaPath, arela-api SQL filters, IdentifyCommand counters)
+  // already accepts `pedimento_completo_xml`.
+  // pedimentoCompletoXmlDefinition,
   supportDocumentDefinition,
   dodaPdfDefinition,
   dodaXmlDefinition,
@@ -96,12 +105,13 @@ export function extractDocumentFields(source, fileExtension, filePath) {
 
       console.log(`   → Resolved type: ${resolvedType}`);
 
-      // Extract pedimento number and year
+      // Extract pedimento number and year. `filePath` is forwarded so XML
+      // matchers (which compose numPedimento from the filename) can use it.
       const pedimento = docType.extractNumPedimento
-        ? docType.extractNumPedimento(source, fields)
+        ? docType.extractNumPedimento(source, fields, filePath)
         : null;
       const year = docType.extractPedimentoYear
-        ? docType.extractPedimentoYear(source, fields)
+        ? docType.extractPedimentoYear(source, fields, filePath)
         : null;
 
       return [resolvedType, fields, pedimento, year];