@arela/uploader 0.3.0 → 1.0.0

package/src/services/upload/ApiUploadService.js

@@ -13,12 +13,15 @@ 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;
@@ -51,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
@@ -58,6 +102,8 @@ 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}`);
@@ -67,8 +113,9 @@ export class ApiUploadService extends BaseUploadService {
     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 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}`);
@@ -131,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));
@@ -181,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;
     }
@@ -200,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

package/src/services/upload/MultiApiUploadService.js

@@ -0,0 +1,233 @@
+import { Agent } from 'http';
+import { Agent as HttpsAgent } from 'https';
+import fetch from 'node-fetch';
+
+import appConfig from '../../config/config.js';
+import logger from '../LoggingService.js';
+import { ApiUploadService } from './ApiUploadService.js';
+
+/**
+ * Multi-API Upload Service
+ *
+ * Extends ApiUploadService to support uploading to multiple API instances
+ * based on RFC/client routing. Uses service discovery from Global API.
+ */
+export class MultiApiUploadService extends ApiUploadService {
+  constructor() {
+    super();
+
+    // Service discovery configuration
+    this.globalApiUrl = process.env.API_GLOBAL_URL || appConfig.api.baseUrl;
+    this.serviceCache = new Map(); // RFC -> { url, cachedAt }
+    this.cacheTtlMs = parseInt(process.env.SERVICE_CACHE_TTL) || 300000; // 5 minutes
+
+    logger.info('🌐 MultiApiUploadService initialized');
+    logger.info(`   Global API: ${this.globalApiUrl}`);
+  }
+
+  /**
+   * Discover service URL for a specific RFC
+   * @param {string} rfc - The client RFC
+   * @returns {Promise<string|null>} Service URL or null
+   */
+  async discoverServiceByRfc(rfc) {
+    const rfcUpper = rfc.toUpperCase();
+
+    // Check cache first
+    const cached = this.serviceCache.get(rfcUpper);
+    if (cached && Date.now() - cached.cachedAt < this.cacheTtlMs) {
+      logger.debug(
+        `📋 Using cached service URL for ${rfcUpper}: ${cached.url}`,
+      );
+      return cached.url;
+    }
+
+    // Fetch from Global API
+    try {
+      const response = await fetch(
+        `${this.globalApiUrl}/api/service-registry/by-rfc/${rfcUpper}`,
+        {
+          method: 'GET',
+          headers: {
+            Authorization: `Bearer ${this.token}`,
+            'Content-Type': 'application/json',
+          },
+          agent: this.globalApiUrl.startsWith('https')
+            ? this.httpsAgent
+            : this.httpAgent,
+        },
+      );
+
+      if (!response.ok) {
+        logger.warn(
+          `⚠️ Service discovery failed for ${rfcUpper}: ${response.status}`,
+        );
+        return null;
+      }
+
+      const data = await response.json();
+
+      if (data.url) {
+        // Cache the result
+        this.serviceCache.set(rfcUpper, {
+          url: data.url,
+          cachedAt: Date.now(),
+        });
+
+        logger.info(`🔍 Discovered service for ${rfcUpper}: ${data.url}`);
+        return data.url;
+      }
+
+      return null;
+    } catch (error) {
+      logger.error(
+        `❌ Service discovery error for ${rfcUpper}: ${error.message}`,
+      );
+      return null;
+    }
+  }
+
+  /**
+   * Clear service cache
+   */
+  clearCache() {
+    this.serviceCache.clear();
+    logger.info('🧹 Service cache cleared');
+  }
+
+  /**
+   * Clear cache for specific RFC
+   * @param {string} rfc - The RFC to clear
+   */
+  clearRfcCache(rfc) {
+    this.serviceCache.delete(rfc.toUpperCase());
+  }
+
+  /**
+   * Upload files to the appropriate API based on RFC
+   * @param {Array} files - Array of file objects
+   * @param {Object} options - Upload options including rfc
+   * @returns {Promise<Object>} API response
+   */
+  async upload(files, options) {
+    const { rfc } = options;
+
+    if (!rfc) {
+      // No RFC specified, use default API
+      return super.upload(files, options);
+    }
+
+    // Discover the service URL for this RFC
+    const serviceUrl = await this.discoverServiceByRfc(rfc);
+
+    if (serviceUrl) {
+      // Override baseUrl for this upload
+      const originalBaseUrl = this.baseUrl;
+      this.baseUrl = serviceUrl;
+
+      try {
+        logger.info(
+          `📤 Uploading ${files.length} files to ${serviceUrl} (RFC: ${rfc})`,
+        );
+        const result = await super.upload(files, options);
+        return result;
+      } finally {
+        // Restore original baseUrl
+        this.baseUrl = originalBaseUrl;
+      }
+    }
+
+    // Fallback to default API if service discovery fails
+    logger.warn(`⚠️ No specific service found for ${rfc}, using default API`);
+    return super.upload(files, options);
+  }
+
+  /**
+   * Upload files to multiple RFCs in parallel
+   * @param {Object} filesByRfc - Map of RFC -> files array
+   * @param {Object} options - Upload options
+   * @returns {Promise<Map<string, Object>>} Results by RFC
+   */
+  async uploadToMultipleRfcs(filesByRfc, options = {}) {
+    const results = new Map();
+    const rfcs = Object.keys(filesByRfc);
+
+    logger.info(`📤 Starting multi-RFC upload for ${rfcs.length} RFCs`);
+
+    // Process RFCs in parallel (with concurrency limit)
+    const concurrencyLimit = parseInt(process.env.MULTI_RFC_CONCURRENCY) || 3;
+    const chunks = [];
+
+    for (let i = 0; i < rfcs.length; i += concurrencyLimit) {
+      chunks.push(rfcs.slice(i, i + concurrencyLimit));
+    }
+
+    for (const chunk of chunks) {
+      await Promise.all(
+        chunk.map(async (rfc) => {
+          try {
+            const files = filesByRfc[rfc];
+            const result = await this.upload(files, { ...options, rfc });
+            results.set(rfc, { success: true, result });
+          } catch (error) {
+            logger.error(`❌ Upload failed for RFC ${rfc}: ${error.message}`);
+            results.set(rfc, { success: false, error: error.message });
+          }
+        }),
+      );
+    }
+
+    // Log summary
+    const successful = [...results.values()].filter((r) => r.success).length;
+    const failed = results.size - successful;
+    logger.info(
+      `✅ Multi-RFC upload complete: ${successful} successful, ${failed} failed`,
+    );
+
+    return results;
+  }
+
+  /**
+   * Get all available services from Global API
+   * @returns {Promise<Array>} List of services
+   */
+  async getAllServices() {
+    try {
+      const response = await fetch(
+        `${this.globalApiUrl}/api/service-registry/services`,
+        {
+          method: 'GET',
+          headers: {
+            Authorization: `Bearer ${this.token}`,
+            'Content-Type': 'application/json',
+          },
+          agent: this.globalApiUrl.startsWith('https')
+            ? this.httpsAgent
+            : this.httpAgent,
+        },
+      );
+
+      if (!response.ok) {
+        throw new Error(`Failed to fetch services: ${response.status}`);
+      }
+
+      const data = await response.json();
+      return data.services || [];
+    } catch (error) {
+      logger.error(`❌ Failed to get services: ${error.message}`);
+      return [];
+    }
+  }
+
+  /**
+   * Pre-warm cache for a list of RFCs
+   * @param {Array<string>} rfcs - List of RFCs to cache
+   */
+  async prewarmCache(rfcs) {
+    logger.info(`🔥 Pre-warming cache for ${rfcs.length} RFCs`);
+
+    await Promise.all(rfcs.map((rfc) => this.discoverServiceByRfc(rfc)));
+
+    logger.info('✅ Cache pre-warm complete');
+  }
+}