@arela/uploader 1.1.4 → 1.2.0

package/.claude/worktrees/agent-multi-profile/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/.claude/worktrees/agent-multi-profile/src/services/upload/SupabaseUploadService.js

@@ -0,0 +1,148 @@
+import { createClient } from '@supabase/supabase-js';
+import fs from 'fs';
+import mime from 'mime-types';
+
+import appConfig from '../../config/config.js';
+import { BaseUploadService } from './BaseUploadService.js';
+
+/**
+ * Supabase Upload Service
+ * Handles direct uploads to Supabase Storage
+ */
+export class SupabaseUploadService extends BaseUploadService {
+  constructor() {
+    super();
+    this.client = null;
+    this.bucket = appConfig.supabase.bucket;
+  }
+
+  /**
+   * Initialize Supabase client if not already initialized
+   * @private
+   */
+  async #initializeClient() {
+    if (this.client) {
+      return;
+    }
+
+    if (!appConfig.supabase.url || !appConfig.supabase.key || !this.bucket) {
+      const missing = [];
+      if (!appConfig.supabase.url) missing.push('SUPABASE_URL');
+      if (!appConfig.supabase.key) missing.push('SUPABASE_KEY');
+      if (!this.bucket) missing.push('SUPABASE_BUCKET');
+      throw new Error(`Missing Supabase configuration: ${missing.join(', ')}`);
+    }
+
+    console.log(`🔌 Connecting to Supabase: ${appConfig.supabase.url}`);
+    console.log(`📦 Using bucket: ${this.bucket}`);
+
+    this.client = createClient(appConfig.supabase.url, appConfig.supabase.key, {
+      db: {
+        schema: 'public',
+      },
+      auth: {
+        autoRefreshToken: false,
+        persistSession: false,
+      },
+      global: {
+        headers: {
+          'x-client-info': 'arela-uploader',
+        },
+      },
+      // Increase timeout settings to handle large queries
+      realtime: {
+        timeout: 60000, // 60 seconds
+      },
+    });
+
+    // Test connection and bucket access
+    console.log(`🧪 Testing bucket access...`);
+    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}`,
+      );
+    }
+
+    console.log(`✅ Successfully connected to Supabase bucket: ${this.bucket}`);
+  }
+
+  /**
+   * Upload file directly to Supabase
+   * @param {Array} files - Array with single file object
+   * @param {Object} options - Upload options with uploadPath
+   * @returns {Promise<Object>} Upload result
+   */
+  async upload(files, options) {
+    await this.#initializeClient();
+
+    if (files.length !== 1) {
+      throw new Error(
+        'SupabaseUploadService only supports single file uploads',
+      );
+    }
+
+    const file = files[0];
+    const uploadPath = options.uploadPath;
+
+    if (!uploadPath) {
+      throw new Error('uploadPath is required for Supabase uploads');
+    }
+
+    const content = fs.readFileSync(file.path);
+    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, {
+        upsert: true,
+        contentType,
+      });
+
+    if (error) {
+      console.error(
+        `❌ Supabase upload failed for ${normalizedPath}:`,
+        error.message,
+      );
+      return { success: false, error: error.message };
+    }
+
+    console.log(`✅ Supabase upload successful: ${normalizedPath}`);
+    return { success: true, data, uploadPath: normalizedPath };
+  }
+
+  /**
+   * Check if Supabase service is available
+   * @returns {Promise<boolean>} True if available
+   */
+  async isAvailable() {
+    try {
+      await this.#initializeClient();
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+
+  /**
+   * Get service name
+   * @returns {string} Service name
+   */
+  getServiceName() {
+    return 'Supabase';
+  }
+
+  /**
+   * Get Supabase client for database operations
+   * @returns {Object} Supabase client
+   */
+  async getClient() {
+    await this.#initializeClient();
+    return this.client;
+  }
+}

package/.claude/worktrees/agent-multi-profile/src/services/upload/UploadServiceFactory.js

@@ -0,0 +1,100 @@
+import { ApiUploadService } from './ApiUploadService.js';
+import { SupabaseUploadService } from './SupabaseUploadService.js';
+
+/**
+ * Upload Service Factory
+ * Manages upload service selection and initialization
+ */
+export class UploadServiceFactory {
+  constructor() {
+    this.apiService = new ApiUploadService();
+    this.supabaseService = new SupabaseUploadService();
+    // Cache for target-specific API services
+    this._targetServices = new Map();
+  }
+
+  /**
+   * Get the appropriate upload service based on availability and preferences
+   * @param {boolean} forceSupabase - Force Supabase mode
+   * @returns {Promise<BaseUploadService>} Upload service instance
+   * @throws {Error} If no service is available
+   */
+  async getUploadService(forceSupabase = false) {
+    if (forceSupabase) {
+      console.log('🔧 Force Supabase mode enabled - skipping API');
+
+      if (await this.supabaseService.isAvailable()) {
+        console.log(
+          `✅ Connected to ${this.supabaseService.getServiceName()} (direct mode)`,
+        );
+        return this.supabaseService;
+      } else {
+        throw new Error('Supabase service is not available');
+      }
+    }
+
+    // Try API service first
+    if (await this.apiService.isAvailable()) {
+      console.log(
+        '🌐 API mode enabled - files will be uploaded to Arela API with automatic processing',
+      );
+      console.log(`✅ Connected to ${this.apiService.getServiceName()}`);
+      return this.apiService;
+    }
+
+    // Fallback to Supabase
+    if (await this.supabaseService.isAvailable()) {
+      console.warn(
+        '⚠️ API connection failed, falling back to direct Supabase upload',
+      );
+      console.log(
+        `✅ Connected to ${this.supabaseService.getServiceName()} (direct mode)`,
+      );
+      return this.supabaseService;
+    }
+
+    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
+   */
+  async isApiModeAvailable() {
+    return await this.apiService.isAvailable();
+  }
+
+  /**
+   * Get Supabase service for database operations
+   * @returns {SupabaseUploadService} Supabase service instance
+   */
+  getSupabaseService() {
+    return this.supabaseService;
+  }
+}
+
+// Export singleton instance
+export const uploadServiceFactory = new UploadServiceFactory();
+export default uploadServiceFactory;