@arela/uploader 0.2.13 → 1.0.0

package/src/services/upload/ApiUploadService.js

@@ -7,17 +7,21 @@ import fetch from 'node-fetch';
 import path from 'path';
 
 import appConfig from '../../config/config.js';
+import logger from '../LoggingService.js';
 import { BaseUploadService } from './BaseUploadService.js';
 
 /**
  * API Upload Service
  * Handles uploads to the Arela API with automatic processing
+ * Supports multiple API targets (agencia, cliente, default)
  */
 export class ApiUploadService extends BaseUploadService {
   constructor() {
     super();
-    this.baseUrl = appConfig.api.baseUrl;
-    this.token = appConfig.api.token;
+    // Flag to indicate if config is externally set (cross-tenant mode)
+    this._isExternalConfig = false;
+    // Get initial API config (can be overridden at runtime via setApiTarget)
+    this.#updateApiConfig();
 
     // Get API connection settings from config/environment
     const maxApiConnections = parseInt(process.env.MAX_API_CONNECTIONS) || 10;
@@ -50,6 +54,47 @@ export class ApiUploadService extends BaseUploadService {
     );
   }
 
+  /**
+   * Update API configuration from appConfig
+   * Called on initialization and when API target changes
+   * Skip if externally configured (cross-tenant mode)
+   * @private
+   */
+  #updateApiConfig() {
+    // Skip update if config is externally set
+    if (this._isExternalConfig) {
+      return;
+    }
+    const apiConfig = appConfig.getApiConfig();
+    this.baseUrl = apiConfig.baseUrl;
+    this.token = apiConfig.token;
+  }
+
+  /**
+   * Set external configuration (for cross-tenant mode)
+   * Prevents automatic config refresh from overwriting these values
+   * @param {string} baseUrl - API base URL
+   * @param {string} token - API token
+   */
+  setExternalConfig(baseUrl, token) {
+    this._isExternalConfig = true;
+    this.baseUrl = baseUrl;
+    this.token = token;
+  }
+
+  /**
+   * Get current API configuration (refreshes from appConfig)
+   * This ensures we always use the latest target configuration
+   * @returns {Object} Current API config with baseUrl and token
+   */
+  getApiConfig() {
+    this.#updateApiConfig();
+    return {
+      baseUrl: this.baseUrl,
+      token: this.token,
+    };
+  }
+
   /**
    * Upload files to Arela API with automatic detection and organization
    * @param {Array} files - Array of file objects
@@ -57,10 +102,34 @@ export class ApiUploadService extends BaseUploadService {
    * @returns {Promise<Object>} API response
    */
   async upload(files, options) {
+    // Refresh config to get current API target
+    this.#updateApiConfig();
+    // Validate files parameter
+    if (!files || !Array.isArray(files)) {
+      logger.warn(`Invalid files parameter: ${typeof files}`);
+      throw new Error('Files must be an array');
+    }
+
     const formData = new FormData();
 
+    // Filter out system files (macOS, Windows, etc.)
+    const systemFilePattern =
+      /^\.|__pycache__|\.pyc|\.swp|\.swo|Thumbs\.db|desktop\.ini|DS_Store|\$RECYCLE\.BIN|System Volume Information|~\$|\.tmp/i;
+    const filteredFiles = files.filter((file) => {
+      const fileName = file.name || path.basename(file.path);
+      if (systemFilePattern.test(fileName)) {
+        logger.warn(`Skipping system file from upload: ${fileName}`);
+        return false;
+      }
+      return true;
+    });
+
+    if (filteredFiles.length === 0) {
+      throw new Error('No valid files to upload after filtering system files');
+    }
+
     // Add files to form data asynchronously
-    for (const file of files) {
+    for (const file of filteredFiles) {
       try {
         // Check file size for streaming vs buffer approach
         let size = file.size;
@@ -109,6 +178,11 @@ export class ApiUploadService extends BaseUploadService {
       formData.append('clientPath', options.clientPath);
     }
 
+    // Add RFC for multi-database routing (required for cross-tenant uploads)
+    if (options.rfc) {
+      formData.append('rfc', options.rfc);
+    }
+
     // Add processing options
     formData.append('autoDetect', String(options.autoDetect ?? true));
     formData.append('autoOrganize', String(options.autoOrganize ?? false));
@@ -159,6 +233,9 @@ export class ApiUploadService extends BaseUploadService {
    * @returns {Promise<boolean>} True if available
    */
   async isAvailable() {
+    // Refresh config to get current API target
+    this.#updateApiConfig();
+
     if (!this.baseUrl || !this.token) {
       return false;
     }
@@ -178,6 +255,373 @@ export class ApiUploadService extends BaseUploadService {
     }
   }
 
+  /**
+   * Batch upsert file stats to uploader table
+   * @param {Array} records - Array of record objects to upsert
+   * @returns {Promise<Object>} Upsert results { inserted, updated, total }
+   */
+  async batchUpsertStats(records) {
+    if (!records || !Array.isArray(records) || records.length === 0) {
+      return { inserted: 0, updated: 0, total: 0 };
+    }
+
+    try {
+      const isHttps = this.baseUrl.startsWith('https');
+      const response = await fetch(
+        `${this.baseUrl}/api/uploader/batch-upsert`,
+        {
+          method: 'POST',
+          headers: {
+            'x-api-key': this.token,
+            'Content-Type': 'application/json',
+          },
+          body: JSON.stringify(records),
+          agent: isHttps ? this.httpsAgent : this.httpAgent,
+        },
+      );
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(
+          `Batch upsert failed: ${response.status} ${response.statusText} - ${errorText}`,
+        );
+      }
+
+      const result = await response.json();
+      return result;
+    } catch (error) {
+      logger.error(`Batch upsert API error: ${error.message}`);
+      throw error;
+    }
+  }
+
+  /**
+   * Fetch PDF records for pedimento detection
+   * @param {Object} options - Query options
+   * @param {number} options.offset - Pagination offset
+   * @param {number} options.limit - Number of records to fetch
+   * @returns {Promise<Object>} { data: Array, error: Error|null }
+   */
+  async fetchPdfRecordsForDetection(options = {}) {
+    const { offset = 0, limit = 100 } = options;
+
+    try {
+      const isHttps = this.baseUrl.startsWith('https');
+      const url = new URL(`${this.baseUrl}/api/uploader/pdf-records`);
+      url.searchParams.append('offset', offset);
+      url.searchParams.append('limit', limit);
+      url.searchParams.append('status', 'fs-stats');
+      url.searchParams.append('file_extension', 'pdf');
+      url.searchParams.append('is_like_simplificado', 'true');
+
+      const response = await fetch(url.toString(), {
+        method: 'GET',
+        headers: {
+          'x-api-key': this.token,
+          'Content-Type': 'application/json',
+        },
+        agent: isHttps ? this.httpsAgent : this.httpAgent,
+      });
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        return {
+          data: null,
+          error: new Error(
+            `Failed to fetch PDF records: ${response.status} ${response.statusText} - ${errorText}`,
+          ),
+        };
+      }
+
+      const data = await response.json();
+      return { data, error: null };
+    } catch (error) {
+      logger.error(`API fetch PDF records error: ${error.message}`);
+      return { data: null, error };
+    }
+  }
+
+  /**
+   * Batch update detection results
+   * @param {Array} updates - Array of update objects with { id, ...updateData }
+   * @returns {Promise<Object>} Update result { success: boolean, updated: number, errors: Array }
+   */
+  async batchUpdateDetectionResults(updates) {
+    if (!updates || !Array.isArray(updates) || updates.length === 0) {
+      return { success: true, updated: 0, errors: [] };
+    }
+
+    try {
+      const isHttps = this.baseUrl.startsWith('https');
+      const response = await fetch(
+        `${this.baseUrl}/api/uploader/batch-update-detection`,
+        {
+          method: 'PATCH',
+          headers: {
+            'x-api-key': this.token,
+            'Content-Type': 'application/json',
+          },
+          body: JSON.stringify({ updates }),
+          agent: isHttps ? this.httpsAgent : this.httpAgent,
+        },
+      );
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(
+          `Batch update failed: ${response.status} ${response.statusText} - ${errorText}`,
+        );
+      }
+
+      const result = await response.json();
+      return result;
+    } catch (error) {
+      logger.error(`Batch update API error: ${error.message}`);
+      return {
+        success: false,
+        updated: 0,
+        errors: [{ message: error.message }],
+      };
+    }
+  }
+
+  /**
+   * Execute arela_path propagation on the backend
+   * This triggers a server-side process that propagates arela_path from pedimentos to related files
+   * @param {Object} options - Propagation options
+   * @param {Array} options.years - Optional year filter
+   * @returns {Promise<Object>} Propagation result { success: boolean, processedCount, updatedCount, errorCount }
+   */
+  async propagateArelaPath(options = {}) {
+    const { years = [] } = options;
+
+    try {
+      const isHttps = this.baseUrl.startsWith('https');
+      const response = await fetch(
+        `${this.baseUrl}/api/uploader/propagate-arela-path`,
+        {
+          method: 'POST',
+          headers: {
+            'x-api-key': this.token,
+            'Content-Type': 'application/json',
+          },
+          body: JSON.stringify({ years }),
+          agent: isHttps ? this.httpsAgent : this.httpAgent,
+        },
+      );
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(
+          `Arela path propagation failed: ${response.status} ${response.statusText} - ${errorText}`,
+        );
+      }
+
+      const result = await response.json();
+      return result;
+    } catch (error) {
+      logger.error(`Propagate arela_path API error: ${error.message}`);
+      return {
+        success: false,
+        processedCount: 0,
+        updatedCount: 0,
+        errorCount: 1,
+        error: error.message,
+      };
+    }
+  }
+
+  /**
+   * Fetch RFC file count
+   * @param {Object} options - Query options
+   * @param {Array} options.rfcs - Array of RFC values to filter
+   * @returns {Promise<Object>} { count: number, error: Error|null }
+   */
+  async fetchRfcFileCount(options = {}) {
+    const { rfcs = [] } = options;
+
+    if (!rfcs || rfcs.length === 0) {
+      return { count: 0, error: null };
+    }
+
+    try {
+      const isHttps = this.baseUrl.startsWith('https');
+      const url = new URL(`${this.baseUrl}/api/uploader/rfc-file-count`);
+      url.searchParams.append('rfcs', rfcs.join(','));
+
+      const response = await fetch(url.toString(), {
+        method: 'GET',
+        headers: {
+          'x-api-key': this.token,
+          'Content-Type': 'application/json',
+        },
+        agent: isHttps ? this.httpsAgent : this.httpAgent,
+      });
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        return {
+          count: 0,
+          error: new Error(
+            `Failed to fetch RFC file count: ${response.status} ${response.statusText} - ${errorText}`,
+          ),
+        };
+      }
+
+      const data = await response.json();
+      return { count: data.count || 0, error: null };
+    } catch (error) {
+      logger.error(`API fetch RFC file count error: ${error.message}`);
+      return { count: 0, error };
+    }
+  }
+
+  /**
+   * Fetch pedimento records by RFC
+   * @param {Object} options - Query options
+   * @param {Array} options.rfcs - Array of RFC values to filter
+   * @param {Array} options.years - Optional year filter
+   * @param {number} options.offset - Pagination offset
+   * @param {number} options.limit - Number of records to fetch
+   * @returns {Promise<Object>} { data: Array, error: Error|null }
+   */
+  async fetchPedimentosByRfc(options = {}) {
+    const { rfcs = [], years = [], offset = 0, limit = 500 } = options;
+
+    if (!rfcs || rfcs.length === 0) {
+      return { data: [], error: null };
+    }
+
+    try {
+      const isHttps = this.baseUrl.startsWith('https');
+      const url = new URL(`${this.baseUrl}/api/uploader/pedimentos-by-rfc`);
+      url.searchParams.append('rfcs', rfcs.join(','));
+      if (years && years.length > 0) {
+        url.searchParams.append('years', years.join(','));
+      }
+      url.searchParams.append('offset', offset);
+      url.searchParams.append('limit', limit);
+
+      const response = await fetch(url.toString(), {
+        method: 'GET',
+        headers: {
+          'x-api-key': this.token,
+          'Content-Type': 'application/json',
+        },
+        agent: isHttps ? this.httpsAgent : this.httpAgent,
+      });
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        return {
+          data: null,
+          error: new Error(
+            `Failed to fetch pedimentos by RFC: ${response.status} ${response.statusText} - ${errorText}`,
+          ),
+        };
+      }
+
+      const data = await response.json();
+      return { data, error: null };
+    } catch (error) {
+      logger.error(`API fetch pedimentos by RFC error: ${error.message}`);
+      return { data: null, error };
+    }
+  }
+
+  /**
+   * Fetch files for upload by arela_path
+   * @param {Object} options - Query options
+   * @param {Array} options.arelaPaths - Array of arela_path values to filter
+   * @param {number} options.offset - Pagination offset
+   * @param {number} options.limit - Number of records to fetch
+   * @returns {Promise<Object>} { data: Array, error: Error|null }
+   */
+  async fetchFilesForUpload(options = {}) {
+    const { arelaPaths = [], offset = 0, limit = 1000 } = options;
+
+    if (!arelaPaths || arelaPaths.length === 0) {
+      return { data: [], error: null };
+    }
+
+    try {
+      const isHttps = this.baseUrl.startsWith('https');
+      const url = new URL(`${this.baseUrl}/api/uploader/files-for-upload`);
+      url.searchParams.append('arela_paths', arelaPaths.join('|'));
+      url.searchParams.append('offset', offset);
+      url.searchParams.append('limit', limit);
+
+      const response = await fetch(url.toString(), {
+        method: 'GET',
+        headers: {
+          'x-api-key': this.token,
+          'Content-Type': 'application/json',
+        },
+        agent: isHttps ? this.httpsAgent : this.httpAgent,
+      });
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        return {
+          data: null,
+          error: new Error(
+            `Failed to fetch files for upload: ${response.status} ${response.statusText} - ${errorText}`,
+          ),
+        };
+      }
+
+      const data = await response.json();
+      return { data, error: null };
+    } catch (error) {
+      logger.error(`API fetch files for upload error: ${error.message}`);
+      return { data: null, error };
+    }
+  }
+
+  /**
+   * Update file status after upload
+   * @param {Array} updates - Array of update objects with { id, status, message, processing_status }
+   * @returns {Promise<Object>} Update result { success: boolean, updated: number, errors: Array }
+   */
+  async updateFileStatus(updates) {
+    if (!updates || !Array.isArray(updates) || updates.length === 0) {
+      return { success: true, updated: 0, errors: [] };
+    }
+
+    try {
+      const isHttps = this.baseUrl.startsWith('https');
+      const response = await fetch(
+        `${this.baseUrl}/api/uploader/batch-update-status`,
+        {
+          method: 'PATCH',
+          headers: {
+            'x-api-key': this.token,
+            'Content-Type': 'application/json',
+          },
+          body: JSON.stringify({ updates }),
+          agent: isHttps ? this.httpsAgent : this.httpAgent,
+        },
+      );
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(
+          `Batch status update failed: ${response.status} ${response.statusText} - ${errorText}`,
+        );
+      }
+
+      const result = await response.json();
+      return result;
+    } catch (error) {
+      logger.error(`Batch status update API error: ${error.message}`);
+      return {
+        success: false,
+        updated: 0,
+        errors: [{ message: error.message }],
+      };
+    }
+  }
+
   /**
    * Get service name
    * @returns {string} Service name