@arela/uploader 0.2.13 → 1.0.0

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');
+  }
+}

package/src/services/upload/SupabaseUploadService.js

@@ -57,12 +57,16 @@ export class SupabaseUploadService extends BaseUploadService {
 
     // Test connection and bucket access
     console.log(`🧪 Testing bucket access...`);
-    const { error } = await this.client.storage.from(this.bucket).list('', { limit: 1 });
+    const { error } = await this.client.storage
+      .from(this.bucket)
+      .list('', { limit: 1 });
     if (error) {
       console.error(`❌ Bucket access test failed:`, error.message);
-      throw new Error(`Error connecting to Supabase bucket '${this.bucket}': ${error.message}`);
+      throw new Error(
+        `Error connecting to Supabase bucket '${this.bucket}': ${error.message}`,
+      );
     }
-    
+
     console.log(`✅ Successfully connected to Supabase bucket: ${this.bucket}`);
   }
 
@@ -92,7 +96,7 @@ export class SupabaseUploadService extends BaseUploadService {
     const contentType = mime.lookup(file.path) || 'application/octet-stream';
 
     const normalizedPath = uploadPath.replace(/\\/g, '/');
-    
+
     const { data, error } = await this.client.storage
       .from(this.bucket)
       .upload(normalizedPath, content, {
@@ -101,7 +105,10 @@ export class SupabaseUploadService extends BaseUploadService {
       });
 
     if (error) {
-      console.error(`❌ Supabase upload failed for ${normalizedPath}:`, error.message);
+      console.error(
+        `❌ Supabase upload failed for ${normalizedPath}:`,
+        error.message,
+      );
       return { success: false, error: error.message };
     }
 

package/src/services/upload/UploadServiceFactory.js

@@ -9,6 +9,8 @@ export class UploadServiceFactory {
   constructor() {
     this.apiService = new ApiUploadService();
     this.supabaseService = new SupabaseUploadService();
+    // Cache for target-specific API services
+    this._targetServices = new Map();
   }
 
   /**
@@ -54,6 +56,28 @@ export class UploadServiceFactory {
     throw new Error('No upload service is available');
   }
 
+  /**
+   * Get an API service configured for a specific target
+   * @param {string} target - API target: 'agencia', 'cliente', 'ktj931117p55', or 'default'
+   * @returns {Promise<ApiUploadService>} API service for the specified target
+   */
+  async getApiServiceForTarget(target) {
+    // Import config dynamically to avoid circular dependency
+    const { appConfig } = await import('../../config/config.js');
+
+    const targetConfig = appConfig.getApiConfig(target);
+    if (!targetConfig.baseUrl) {
+      throw new Error(`No API URL configured for target '${target}'`);
+    }
+
+    // Create a new service instance with specific config
+    // Use setExternalConfig to prevent automatic config refresh from overwriting
+    const service = new ApiUploadService();
+    service.setExternalConfig(targetConfig.baseUrl, targetConfig.token);
+
+    return service;
+  }
+
   /**
    * Check if API mode is currently active
    * @returns {Promise<boolean>} True if API service is available

package/src/utils/CleanupManager.js

@@ -0,0 +1,262 @@
+import logger from '../services/LoggingService.js';
+
+/**
+ * Cleanup Manager
+ * Centralizes and coordinates cleanup of resources during graceful shutdown
+ * Ensures resources are cleaned up in reverse order of registration (LIFO)
+ */
+export class CleanupManager {
+  constructor() {
+    /**
+     * Array of registered resources
+     * @type {Array<{name: string, resource: any, cleanupFn: Function}>}
+     */
+    this.resources = [];
+
+    /**
+     * Flag to prevent concurrent cleanup
+     * @type {boolean}
+     */
+    this.cleanupInProgress = false;
+
+    /**
+     * Timestamp when cleanup started
+     * @type {number|null}
+     */
+    this.cleanupStartTime = null;
+
+    /**
+     * Cleanup timeout duration (30 seconds)
+     * @type {number}
+     */
+    this.cleanupTimeout = 30000;
+
+    /**
+     * Results of cleanup operations
+     * @type {Array<{name: string, success: boolean, duration: number, error: string|null}>}
+     */
+    this.cleanupResults = [];
+  }
+
+  /**
+   * Register a resource to be cleaned up during shutdown
+   * Resources are cleaned up in reverse order (LIFO)
+   * @param {string} name - Name of the resource
+   * @param {any} resource - The resource object
+   * @param {Function} cleanupFn - Async function to clean up the resource
+   * @returns {void}
+   */
+  registerResource(name, resource, cleanupFn) {
+    if (!name || typeof name !== 'string') {
+      logger.warn('CleanupManager: Resource name must be a non-empty string');
+      return;
+    }
+
+    if (typeof cleanupFn !== 'function') {
+      logger.warn(
+        `CleanupManager: Cleanup function for "${name}" is not a function`,
+      );
+      return;
+    }
+
+    this.resources.push({
+      name,
+      resource,
+      cleanupFn,
+    });
+
+    logger.debug(`CleanupManager: Registered resource "${name}"`);
+  }
+
+  /**
+   * Perform cleanup of all registered resources in reverse order
+   * @param {string} reason - Reason for cleanup (e.g., 'SIGINT', 'SIGTERM')
+   * @returns {Promise<Object>} Cleanup results
+   */
+  async performCleanup(reason = 'unknown') {
+    // Prevent concurrent cleanup operations
+    if (this.cleanupInProgress) {
+      logger.warn(
+        `CleanupManager: Cleanup already in progress, skipping new cleanup request`,
+      );
+      return {
+        success: false,
+        reason: 'Cleanup already in progress',
+        results: this.cleanupResults,
+      };
+    }
+
+    this.cleanupInProgress = true;
+    this.cleanupStartTime = Date.now();
+    this.cleanupResults = [];
+
+    logger.info(
+      `CleanupManager: Starting cleanup sequence (reason: ${reason})`,
+    );
+
+    // Set timeout for cleanup
+    const cleanupTimeoutId = setTimeout(() => {
+      logger.error('CleanupManager: Cleanup timeout reached, forcing exit');
+    }, this.cleanupTimeout);
+
+    // Clean up resources in reverse order (LIFO)
+    for (let i = this.resources.length - 1; i >= 0; i--) {
+      const { name, cleanupFn } = this.resources[i];
+      const startTime = Date.now();
+
+      try {
+        logger.debug(`CleanupManager: Cleaning up resource "${name}"...`);
+
+        // Execute cleanup function
+        const result = cleanupFn();
+
+        // Handle both sync and async cleanup functions
+        if (result && typeof result.catch === 'function') {
+          await result;
+        }
+
+        const duration = Date.now() - startTime;
+        this.cleanupResults.push({
+          name,
+          success: true,
+          duration,
+          error: null,
+        });
+
+        logger.info(
+          `CleanupManager: Successfully cleaned up "${name}" (${duration}ms)`,
+        );
+      } catch (error) {
+        const duration = Date.now() - startTime;
+        this.cleanupResults.push({
+          name,
+          success: false,
+          duration,
+          error: error.message,
+        });
+
+        logger.error(
+          `CleanupManager: Error cleaning up "${name}": ${error.message}`,
+        );
+      }
+    }
+
+    // Clear timeout
+    clearTimeout(cleanupTimeoutId);
+
+    const totalDuration = Date.now() - this.cleanupStartTime;
+    const successCount = this.cleanupResults.filter((r) => r.success).length;
+    const failureCount = this.cleanupResults.filter((r) => !r.success).length;
+
+    logger.info(
+      `CleanupManager: Cleanup complete (${totalDuration}ms, ${successCount} successful, ${failureCount} failed)`,
+    );
+
+    return {
+      success: failureCount === 0,
+      reason,
+      totalDuration,
+      successCount,
+      failureCount,
+      results: this.cleanupResults,
+    };
+  }
+
+  /**
+   * Clear all registered resources without cleaning them up
+   * Use this for resetting the cleanup manager
+   * @returns {void}
+   */
+  clearResources() {
+    const count = this.resources.length;
+    this.resources = [];
+    logger.debug(`CleanupManager: Cleared ${count} registered resources`);
+  }
+
+  /**
+   * Get the number of registered resources
+   * @returns {number} Number of registered resources
+   */
+  getResourceCount() {
+    return this.resources.length;
+  }
+
+  /**
+   * Get details of all registered resources
+   * @returns {Array<string>} Array of resource names
+   */
+  getResourceNames() {
+    return this.resources.map((r) => r.name);
+  }
+
+  /**
+   * Check if cleanup is in progress
+   * @returns {boolean} True if cleanup is currently running
+   */
+  isCleanupInProgress() {
+    return this.cleanupInProgress;
+  }
+
+  /**
+   * Get cleanup results from last operation
+   * @returns {Array<Object>} Array of cleanup results
+   */
+  getCleanupResults() {
+    return [...this.cleanupResults];
+  }
+
+  /**
+   * Generate a formatted report of the cleanup operation
+   * @returns {string} Formatted cleanup report
+   */
+  generateCleanupReport() {
+    if (this.cleanupResults.length === 0) {
+      return 'No cleanup operations recorded';
+    }
+
+    const totalDuration = this.cleanupStartTime
+      ? Date.now() - this.cleanupStartTime
+      : 0;
+
+    let report =
+      '\n═══════════════════════════════════════════════════════════\n';
+    report += 'CLEANUP OPERATION REPORT\n';
+    report += '═══════════════════════════════════════════════════════════\n\n';
+
+    for (const result of this.cleanupResults) {
+      const status = result.success ? '✅' : '❌';
+      report += `${status} ${result.name}\n`;
+      report += `   Duration: ${result.duration}ms\n`;
+      if (result.error) {
+        report += `   Error: ${result.error}\n`;
+      }
+      report += '\n';
+    }
+
+    const successCount = this.cleanupResults.filter((r) => r.success).length;
+    const failureCount = this.cleanupResults.filter((r) => !r.success).length;
+
+    report += '─────────────────────────────────────────────────────────────\n';
+    report += `Total Duration: ${totalDuration}ms\n`;
+    report += `Successful: ${successCount}\n`;
+    report += `Failed: ${failureCount}\n`;
+    report += '═══════════════════════════════════════════════════════════\n';
+
+    return report;
+  }
+
+  /**
+   * Reset cleanup state (useful for testing)
+   * @returns {void}
+   */
+  reset() {
+    this.cleanupInProgress = false;
+    this.cleanupStartTime = null;
+    this.cleanupResults = [];
+    logger.debug('CleanupManager: Reset to initial state');
+  }
+}
+
+// Export singleton instance
+export const cleanupManager = new CleanupManager();
+export default cleanupManager;

package/src/utils/FileOperations.js

@@ -143,6 +143,50 @@ export class FileOperations {
       return false;
     }
   }
+
+  /**
+   * List all files in a directory (non-recursive)
+   * @param {string} dirPath - Directory path
+   * @param {Object} options - Options { excludePattern, onlyPdf }
+   * @returns {Array} Array of file paths
+   */
+  static listFilesInDirectory(dirPath, options = {}) {
+    try {
+      const {
+        excludePattern = /(^|[\/\\])\.|node_modules|\.git/,
+        onlyPdf = false,
+      } = options;
+
+      if (!fs.existsSync(dirPath)) {
+        return [];
+      }
+
+      const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+      const files = [];
+
+      for (const entry of entries) {
+        const fullPath = path.join(dirPath, entry.name);
+
+        // Skip excluded patterns
+        if (excludePattern && excludePattern.test(fullPath)) {
+          continue;
+        }
+
+        // Only include files, not directories
+        if (entry.isFile()) {
+          // If onlyPdf is true, filter for PDF files
+          if (onlyPdf && !entry.name.toLowerCase().endsWith('.pdf')) {
+            continue;
+          }
+          files.push(fullPath);
+        }
+      }
+
+      return files;
+    } catch (error) {
+      return [];
+    }
+  }
 }
 
 export default FileOperations;