@arela/uploader 0.3.0 → 1.0.0

package/src/services/AutoProcessingService.js

@@ -1,12 +1,20 @@
+import { appConfig } from '../config/config.js';
 import logger from './LoggingService.js';
 
 /**
  * AutoProcessingService - Handles automatic processing workflow for newly detected files
  * Executes the 4-step processing pipeline:
- * 1. Stats collection (stats --stats-only)
- * 2. PDF/Pedimento detection (detect --detect-pdfs)
- * 3. Arela path propagation (detect --propagate-arela-path)
- * 4. RFC-based upload with folder structure (upload --upload-by-rfc --folder-structure)
+ * 1. Stats collection (stats --stats-only) - uses sourceApi in cross-tenant mode
+ * 2. PDF/Pedimento detection (detect --detect-pdfs) - uses sourceApi in cross-tenant mode
+ * 3. Arela path propagation (detect --propagate-arela-path) - uses sourceApi in cross-tenant mode
+ * 4. RFC-based upload with folder structure (upload --upload-by-rfc --folder-structure) - uses targetApi in cross-tenant mode
+ *
+ * In cross-tenant mode (--source-api and --target-api):
+ * - Phases 1-3 write/update to the SOURCE API
+ * - Phase 4 uploads files to the TARGET API
+ *
+ * In single API mode (--api):
+ * - All phases use the same API
  */
 export class AutoProcessingService {
   constructor() {
@@ -54,7 +62,7 @@ export class AutoProcessingService {
           pipelineId,
         };
       }
-      
+
       logger.warn(
         '⚠️ Processing pipeline already running, skipping new request',
       );
@@ -67,7 +75,7 @@ export class AutoProcessingService {
 
     this.isProcessing = true;
     this.lastProcessedFile = filePath;
-    
+
     // Set automatic timeout to reset processing flag (fail-safe)
     this.#setProcessingTimeout();
     const results = {
@@ -86,12 +94,33 @@ export class AutoProcessingService {
     };
 
     try {
-      // Step 1: Run stats collection
+      // Determine API target for phases 1-3 (write operations)
+      // In cross-tenant mode: use sourceApi for phases 1-3
+      // In single API mode: use activeTarget
+      const isCrossTenant = appConfig.isCrossTenantMode();
+      const sourceApiTarget = isCrossTenant
+        ? appConfig.api.sourceTarget
+        : appConfig.api.activeTarget !== 'default'
+          ? appConfig.api.activeTarget
+          : null;
+
+      if (isCrossTenant) {
+        logger.debug(
+          `🔀 Cross-tenant mode: phases 1-3 will use ${appConfig.api.sourceTarget}, phase 4 will use ${appConfig.api.targetTarget}`,
+        );
+      } else if (sourceApiTarget) {
+        logger.debug(
+          `🎯 Single API mode: all phases will use ${sourceApiTarget}`,
+        );
+      }
+
+      // Step 1: Run stats collection (uses sourceApi in cross-tenant mode)
       logger.debug(`📊 [Step 1/4] Stats collection...`);
       results.steps.statsOnly = await this.#executeStatsOnly({
         filePath,
         watchDir,
         batchSize,
+        apiTarget: sourceApiTarget,
       });
 
       if (results.steps.statsOnly.status === 'failed') {
@@ -103,10 +132,11 @@ export class AutoProcessingService {
         return results;
       }
 
-      // Step 2: Run PDF detection
+      // Step 2: Run PDF detection (uses sourceApi in cross-tenant mode)
       logger.debug(`🔍 [Step 2/4] PDF detection...`);
       results.steps.detectPdfs = await this.#executeDetectPdfs({
         batchSize,
+        apiTarget: sourceApiTarget,
       });
 
       if (results.steps.detectPdfs.status === 'failed') {
@@ -122,10 +152,11 @@ export class AutoProcessingService {
         return results;
       }
 
-      // Step 3: Propagate Arela path
+      // Step 3: Propagate Arela path (uses sourceApi in cross-tenant mode)
       logger.debug(`🔄 [Step 3/4] Arela path propagation...`);
-      results.steps.propagateArelaPath =
-        await this.#executePropagateArelaPath();
+      results.steps.propagateArelaPath = await this.#executePropagateArelaPath({
+        apiTarget: sourceApiTarget,
+      });
 
       if (results.steps.propagateArelaPath.status === 'failed') {
         logger.debug(
@@ -140,6 +171,8 @@ export class AutoProcessingService {
       }
 
       // Step 4: Upload by RFC with folder structure
+      // In cross-tenant mode: uses sourceApi for reading, targetApi for uploading
+      // In single API mode: uses the same API for both
       logger.debug(`📤 [Step 4/4] RFC upload...`);
       results.steps.uploadByRfc = await this.#executeUploadByRfc({
         batchSize,
@@ -191,17 +224,22 @@ export class AutoProcessingService {
       // Import DatabaseService to collect stats directly
       // This bypasses UploadCommand which has watch mode restrictions
       const databaseService = (await import('./DatabaseService.js')).default;
-      const FileOperations = (await import('../utils/FileOperations.js')).default;
+      const FileOperations = (await import('../utils/FileOperations.js'))
+        .default;
       const fs = (await import('fs')).default;
       const path = (await import('path')).default;
 
-      logger.debug(`[AutoProcessingService] Executing stats collection for watch mode`);
+      logger.debug(
+        `[AutoProcessingService] Executing stats collection for watch mode`,
+      );
 
       // Get files from the watch directory
       const { filePath, watchDir } = options;
-      
+
       if (!filePath || !watchDir) {
-        throw new Error('filePath and watchDir are required for stats collection');
+        throw new Error(
+          'filePath and watchDir are required for stats collection',
+        );
       }
 
       // Wait for file to be fully written (with retries)
@@ -217,14 +255,18 @@ export class AutoProcessingService {
           } else {
             attempts++;
             if (attempts < maxAttempts) {
-              logger.debug(`File not yet ready (attempt ${attempts}/${maxAttempts}), waiting...`);
+              logger.debug(
+                `File not yet ready (attempt ${attempts}/${maxAttempts}), waiting...`,
+              );
               await new Promise((resolve) => setTimeout(resolve, retryDelay));
             }
           }
         } catch (error) {
           attempts++;
           if (attempts < maxAttempts) {
-            logger.debug(`Error reading file stats (attempt ${attempts}/${maxAttempts}): ${error.message}, retrying...`);
+            logger.debug(
+              `Error reading file stats (attempt ${attempts}/${maxAttempts}): ${error.message}, retrying...`,
+            );
             await new Promise((resolve) => setTimeout(resolve, retryDelay));
           } else {
             throw error;
@@ -233,7 +275,9 @@ export class AutoProcessingService {
       }
 
       if (!fileStats) {
-        throw new Error(`File not found after ${maxAttempts} retries: ${filePath}`);
+        throw new Error(
+          `File not found after ${maxAttempts} retries: ${filePath}`,
+        );
       }
 
       // Get the parent directory of the detected file
@@ -257,7 +301,10 @@ export class AutoProcessingService {
       // Add all related files (except the one already detected)
       for (const relatedFilePath of relatedFiles) {
         // Skip the file already detected and .DS_Store
-        if (relatedFilePath === filePath || relatedFilePath.endsWith('.DS_Store')) {
+        if (
+          relatedFilePath === filePath ||
+          relatedFilePath.endsWith('.DS_Store')
+        ) {
           continue;
         }
 
@@ -271,18 +318,32 @@ export class AutoProcessingService {
             });
           }
         } catch (error) {
-          logger.debug(`Could not read stats for related file: ${relatedFilePath}`);
+          logger.debug(
+            `Could not read stats for related file: ${relatedFilePath}`,
+          );
         }
       }
 
-      logger.debug(`📊 Found ${fileObjects.length} file(s) to process (1 detected + ${fileObjects.length - 1} related)`);
+      logger.debug(
+        `📊 Found ${fileObjects.length} file(s) to process (1 detected + ${fileObjects.length - 1} related)`,
+      );
+
+      // Insert into database directly, using the specified API target
+      const insertOptions = {
+        quietMode: true, // Suppress verbose logging when in auto-pipeline
+      };
+
+      // Pass apiTarget if specified (for cross-tenant or single API mode)
+      if (options.apiTarget) {
+        insertOptions.apiTarget = options.apiTarget;
+        logger.debug(
+          `[AutoProcessingService] Stats using API target: ${options.apiTarget}`,
+        );
+      }
 
-      // Insert into database directly
       const result = await databaseService.insertStatsOnlyToUploaderTable(
         fileObjects,
-        {
-          quietMode: true, // Suppress verbose logging when in auto-pipeline
-        },
+        insertOptions,
       );
 
       const duration = Date.now() - stepStartTime;
@@ -314,6 +375,7 @@ export class AutoProcessingService {
    * Execute PDF detection (Step 2)
    * @private
    * @param {Object} options - Options for PDF detection
+   * @param {string} options.apiTarget - API target to use (for cross-tenant or single API mode)
    * @returns {Promise<Object>} Result of PDF detection
    */
   async #executeDetectPdfs(options = {}) {
@@ -326,9 +388,20 @@ export class AutoProcessingService {
         `[AutoProcessingService] Executing PDF detection with batch size: ${options.batchSize}`,
       );
 
-      const result = await databaseService.detectPedimentosInDatabase({
+      // Pass apiTarget if specified
+      const detectOptions = {
         batchSize: options.batchSize || 10,
-      });
+      };
+
+      if (options.apiTarget) {
+        detectOptions.apiTarget = options.apiTarget;
+        logger.debug(
+          `[AutoProcessingService] PDF detection using API target: ${options.apiTarget}`,
+        );
+      }
+
+      const result =
+        await databaseService.detectPedimentosInDatabase(detectOptions);
 
       const duration = Date.now() - stepStartTime;
       logger.info(`✅ PDF detection completed in ${duration}ms`);
@@ -358,9 +431,11 @@ export class AutoProcessingService {
   /**
    * Execute arela_path propagation (Step 3)
    * @private
+   * @param {Object} options - Options for propagation
+   * @param {string} options.apiTarget - API target to use (for cross-tenant or single API mode)
    * @returns {Promise<Object>} Result of arela_path propagation
    */
-  async #executePropagateArelaPath() {
+  async #executePropagateArelaPath(options = {}) {
     let stepStartTime = Date.now();
     try {
       // Import databaseService singleton instance
@@ -368,9 +443,19 @@ export class AutoProcessingService {
 
       logger.debug(`[AutoProcessingService] Executing arela_path propagation`);
 
-      const result = await databaseService.propagateArelaPath({
+      // Pass apiTarget if specified
+      const propagateOptions = {
         showProgress: true,
-      });
+      };
+
+      if (options.apiTarget) {
+        propagateOptions.apiTarget = options.apiTarget;
+        logger.debug(
+          `[AutoProcessingService] Propagation using API target: ${options.apiTarget}`,
+        );
+      }
+
+      const result = await databaseService.propagateArelaPath(propagateOptions);
 
       const duration = Date.now() - stepStartTime;
       logger.info(`✅ Arela path propagation completed in ${duration}ms`);
@@ -411,19 +496,44 @@ export class AutoProcessingService {
       // Import databaseService singleton instance
       const databaseService = (await import('./DatabaseService.js')).default;
 
+      // Build upload options, including cross-tenant config if set globally
+      const uploadOptions = {
+        batchSize: options.batchSize || 10,
+        showProgress: true,
+        folderStructure: options.folderStructure,
+      };
+
+      // Check if cross-tenant mode is enabled globally and pass it to uploadFilesByRfc
+      if (appConfig.isCrossTenantMode()) {
+        // Cross-tenant mode: source API for reading, target API for uploading
+        uploadOptions.sourceApi = appConfig.api.sourceTarget;
+        uploadOptions.targetApi = appConfig.api.targetTarget;
+        logger.debug(
+          `[AutoProcessingService] Cross-tenant upload: source=${uploadOptions.sourceApi}, target=${uploadOptions.targetApi}`,
+        );
+      } else if (
+        appConfig.api.activeTarget &&
+        appConfig.api.activeTarget !== 'default'
+      ) {
+        // Single API mode: use the same API for both reading and uploading
+        uploadOptions.apiTarget = appConfig.api.activeTarget;
+        logger.debug(
+          `[AutoProcessingService] Single API upload: target=${uploadOptions.apiTarget}`,
+        );
+      }
+
       logger.debug(
         `[AutoProcessingService] Executing RFC-based upload with options:`,
         {
           folderStructure: options.folderStructure,
           batchSize: options.batchSize,
+          sourceApi: uploadOptions.sourceApi,
+          targetApi: uploadOptions.targetApi,
+          apiTarget: uploadOptions.apiTarget,
         },
       );
 
-      const result = await databaseService.uploadFilesByRfc({
-        batchSize: options.batchSize || 10,
-        showProgress: true,
-        folderStructure: options.folderStructure,
-      });
+      const result = await databaseService.uploadFilesByRfc(uploadOptions);
 
       const duration = Date.now() - stepStartTime;
       logger.info(`✅ RFC upload completed in ${duration}ms`);
@@ -613,7 +723,7 @@ export class AutoProcessingService {
       if (this.isProcessing) {
         logger.warn(
           '⚠️ Processing pipeline timeout - forcing reset after ' +
-          `${this.processingTimeoutDuration}ms`,
+            `${this.processingTimeoutDuration}ms`,
         );
         this.isProcessing = false;
         this.lastProcessedFile = null;