@memberjunction/metadata-sync 2.67.0 → 2.68.0

package/dist/services/PullService.js

@@ -9,14 +9,26 @@ const path_1 = __importDefault(require("path"));
 const core_1 = require("@memberjunction/core");
 const config_1 = require("../config");
 const config_manager_1 = require("../lib/config-manager");
+const file_write_batch_1 = require("../lib/file-write-batch");
+const RecordProcessor_1 = require("../lib/RecordProcessor");
 class PullService {
     syncEngine;
     contextUser;
+    createdBackupFiles = [];
+    createdBackupDirs = new Set();
+    fileWriteBatch;
+    recordProcessor;
     constructor(syncEngine, contextUser) {
         this.syncEngine = syncEngine;
         this.contextUser = contextUser;
+        this.fileWriteBatch = new file_write_batch_1.FileWriteBatch();
+        this.recordProcessor = new RecordProcessor_1.RecordProcessor(syncEngine, contextUser);
     }
     async pull(options, callbacks) {
+        // Clear any previous batch operations
+        this.fileWriteBatch.clear();
+        this.createdBackupFiles = [];
+        this.createdBackupDirs.clear();
         let targetDir;
         let entityConfig;
         // Check if we should use a specific target directory
@@ -55,7 +67,7 @@ class PullService {
             }
         }
         // Show configuration notice only if relevant and in verbose mode
-        if (options.verbose && entityConfig.pull?.appendRecordsToExistingFile && entityConfig.pull?.newFileName) {
+        if (options.verbose && entityConfig?.pull?.appendRecordsToExistingFile && entityConfig?.pull?.newFileName) {
             const targetFile = path_1.default.join(targetDir, entityConfig.pull.newFileName.endsWith('.json')
                 ? entityConfig.pull.newFileName
                 : `${entityConfig.pull.newFileName}.json`);
@@ -70,7 +82,7 @@ class PullService {
         if (options.filter) {
             filter = options.filter;
         }
-        else if (entityConfig.pull?.filter) {
+        else if (entityConfig?.pull?.filter) {
             filter = entityConfig.pull.filter;
         }
         const result = await rv.RunView({
@@ -92,49 +104,40 @@ class PullService {
                 targetDir
             };
         }
-        // Check if we need to wait for async property loading
-        if (entityConfig.pull?.externalizeFields && result.Results.length > 0) {
-            await this.handleAsyncPropertyLoading(options.entity, entityConfig, options.verbose, callbacks);
-        }
-        // Process records
-        const pullResult = await this.processRecords(result.Results, options, targetDir, entityConfig, callbacks);
-        return {
-            ...pullResult,
-            targetDir
-        };
-    }
-    async handleAsyncPropertyLoading(entityName, entityConfig, verbose, callbacks) {
-        const metadata = new core_1.Metadata();
-        const entityInfo = metadata.EntityByName(entityName);
-        if (!entityInfo)
-            return;
-        const externalizeConfig = entityConfig.pull.externalizeFields;
-        let fieldsToExternalize = [];
-        if (Array.isArray(externalizeConfig)) {
-            if (externalizeConfig.length > 0 && typeof externalizeConfig[0] === 'string') {
-                fieldsToExternalize = externalizeConfig;
+        // Process records with error handling and rollback
+        let pullResult;
+        try {
+            pullResult = await this.processRecords(result.Results, options, targetDir, entityConfig, callbacks);
+            // Write all batched file changes at once
+            if (!options.dryRun) {
+                const filesWritten = await this.fileWriteBatch.flush();
+                if (options.verbose && filesWritten > 0) {
+                    callbacks?.onSuccess?.(`Wrote ${filesWritten} files with consistent property ordering`);
+                }
             }
-            else {
-                fieldsToExternalize = externalizeConfig
-                    .map(item => item.field);
+            // Operation succeeded - clean up backup files
+            if (!options.dryRun) {
+                await this.cleanupBackupFiles();
             }
         }
-        else {
-            fieldsToExternalize = Object.keys(externalizeConfig);
-        }
-        // Get all field names from entity metadata
-        const metadataFieldNames = entityInfo.Fields.map(f => f.Name);
-        // Check if any externalized fields are NOT in metadata (likely computed properties)
-        const computedFields = fieldsToExternalize.filter(f => !metadataFieldNames.includes(f));
-        if (computedFields.length > 0) {
-            if (verbose) {
-                callbacks?.onProgress?.(`Waiting 5 seconds for async property loading in ${entityName} (${computedFields.join(', ')})...`);
-            }
-            await new Promise(resolve => setTimeout(resolve, 5000));
-            if (verbose) {
-                callbacks?.onSuccess?.('Async property loading wait complete');
+        catch (error) {
+            callbacks?.onError?.(`Pull operation failed: ${error.message || error}`);
+            // Attempt to rollback file changes if not in dry run mode
+            if (!options.dryRun) {
+                try {
+                    await this.rollbackFileChanges(callbacks);
+                    callbacks?.onWarn?.('File changes have been rolled back due to operation failure');
+                }
+                catch (rollbackError) {
+                    callbacks?.onError?.(`Rollback failed: ${rollbackError.message || rollbackError}`);
+                }
             }
+            throw error;
         }
+        return {
+            ...pullResult,
+            targetDir
+        };
     }
     async processRecords(records, options, targetDir, entityConfig, callbacks) {
         const entityInfo = this.syncEngine.getEntityInfo(options.entity);
@@ -149,7 +152,9 @@ class PullService {
         // If multi-file flag is set, collect all records
         if (options.multiFile) {
             const allRecords = [];
-            for (const record of records) {
+            const errors = [];
+            // Process records in parallel for multi-file mode
+            const recordPromises = records.map(async (record, index) => {
                 try {
                     // Build primary key
                     const primaryKey = {};
@@ -157,23 +162,37 @@ class PullService {
                         primaryKey[pk.Name] = record[pk.Name];
                     }
                     // Process record for multi-file
-                    const recordData = await this.processRecordData(record, primaryKey, targetDir, entityConfig, options.verbose, true);
-                    allRecords.push(recordData);
-                    processed++;
-                    if (options.verbose) {
-                        callbacks?.onProgress?.(`Processing records (${processed}/${records.length})`);
-                    }
+                    const recordData = await this.recordProcessor.processRecord(record, primaryKey, targetDir, entityConfig, options.verbose, true);
+                    return { success: true, recordData, index };
                 }
                 catch (error) {
-                    callbacks?.onWarn?.(`Failed to process record: ${error.message || error}`);
+                    const errorMessage = `Failed to process record ${index + 1}: ${error.message || error}`;
+                    errors.push(errorMessage);
+                    callbacks?.onWarn?.(errorMessage);
+                    return { success: false, recordData: null, index };
+                }
+            });
+            const recordResults = await Promise.all(recordPromises);
+            // Collect successful records
+            for (const result of recordResults) {
+                if (result.success && result.recordData) {
+                    allRecords.push(result.recordData);
+                    processed++;
                 }
             }
-            // Write all records to single file
+            if (options.verbose) {
+                callbacks?.onProgress?.(`Processed ${processed}/${records.length} records in parallel`);
+            }
+            // Queue all records to single file for batched write
             if (allRecords.length > 0) {
                 const fileName = options.multiFile.endsWith('.json') ? options.multiFile : `${options.multiFile}.json`;
                 const filePath = path_1.default.join(targetDir, fileName);
-                await fs_extra_1.default.writeJson(filePath, allRecords, { spaces: 2 });
-                callbacks?.onSuccess?.(`Pulled ${processed} records to ${path_1.default.basename(filePath)}`);
+                this.fileWriteBatch.queueWrite(filePath, allRecords);
+                callbacks?.onSuccess?.(`Queued ${processed} records for ${path_1.default.basename(filePath)}`);
+            }
+            // If there were errors during parallel processing, throw them
+            if (errors.length > 0) {
+                throw new Error(`Multi-file processing completed with ${errors.length} errors:\n${errors.join('\n')}`);
             }
         }
         else {
@@ -195,6 +214,107 @@ class PullService {
         }
         return { processed, created, updated, skipped };
     }
+    /**
+     * Clean up backup files created during the pull operation
+     * Should be called after successful pull operations to remove persistent backup files
+     */
+    async cleanupBackupFiles() {
+        if (this.createdBackupFiles.length === 0 && this.createdBackupDirs.size === 0) {
+            return;
+        }
+        const errors = [];
+        // Remove backup files
+        for (const backupPath of this.createdBackupFiles) {
+            try {
+                if (await fs_extra_1.default.pathExists(backupPath)) {
+                    await fs_extra_1.default.remove(backupPath);
+                }
+            }
+            catch (error) {
+                errors.push(`Failed to remove backup file ${backupPath}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        // Remove empty backup directories
+        for (const backupDir of this.createdBackupDirs) {
+            try {
+                await this.removeEmptyBackupDirectory(backupDir);
+            }
+            catch (error) {
+                errors.push(`Failed to remove backup directory ${backupDir}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        // Clear the tracking arrays
+        this.createdBackupFiles = [];
+        this.createdBackupDirs.clear();
+        if (errors.length > 0) {
+            throw new Error(`Backup cleanup completed with errors:\n${errors.join('\n')}`);
+        }
+    }
+    /**
+     * Remove a backup directory if it's empty
+     */
+    async removeEmptyBackupDirectory(backupDir) {
+        try {
+            // Check if directory exists
+            if (!(await fs_extra_1.default.pathExists(backupDir))) {
+                return;
+            }
+            // Only remove if it's actually a .backups directory for safety
+            if (!backupDir.endsWith('.backups')) {
+                return;
+            }
+            // Check if directory is empty
+            const files = await fs_extra_1.default.readdir(backupDir);
+            if (files.length === 0) {
+                await fs_extra_1.default.remove(backupDir);
+            }
+        }
+        catch (error) {
+            // Log error but don't throw - cleanup should be non-critical
+            // The error will be caught by the caller and included in the error list
+            throw error;
+        }
+    }
+    /**
+     * Get the list of backup files created during the current pull operation
+     */
+    getCreatedBackupFiles() {
+        return [...this.createdBackupFiles];
+    }
+    /**
+     * Rollback file changes by restoring from backup files
+     * Called when pull operation fails after files have been modified
+     */
+    async rollbackFileChanges(callbacks) {
+        if (this.createdBackupFiles.length === 0) {
+            callbacks?.onLog?.('No backup files found - no rollback needed');
+            return;
+        }
+        callbacks?.onProgress?.(`Rolling back ${this.createdBackupFiles.length} file changes...`);
+        const errors = [];
+        let restoredCount = 0;
+        for (const backupPath of this.createdBackupFiles) {
+            try {
+                // Extract original file path from backup path
+                const backupDir = path_1.default.dirname(backupPath);
+                const backupFileName = path_1.default.basename(backupPath);
+                // Remove timestamp and .backup extension to get original filename
+                const originalFileName = backupFileName.replace(/\.\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}-\d{3}Z\.backup$/, '.json');
+                const originalFilePath = path_1.default.join(path_1.default.dirname(backupDir), originalFileName);
+                if (await fs_extra_1.default.pathExists(backupPath)) {
+                    await fs_extra_1.default.copy(backupPath, originalFilePath);
+                    restoredCount++;
+                }
+            }
+            catch (error) {
+                errors.push(`Failed to restore ${backupPath}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        if (errors.length > 0) {
+            throw new Error(`Rollback completed with ${errors.length} errors (${restoredCount} files restored):\n${errors.join('\n')}`);
+        }
+        callbacks?.onSuccess?.(`Successfully rolled back ${restoredCount} file changes`);
+    }
     async processIndividualRecords(records, options, targetDir, entityConfig, entityInfo, callbacks) {
         let processed = 0;
         let updated = 0;
@@ -251,160 +371,131 @@ class PullService {
         }
         // Track which files have been backed up to avoid duplicates
         const backedUpFiles = new Set();
-        // Process existing records updates
-        for (const { record, primaryKey, filePath } of existingRecordsToUpdate) {
-            try {
-                callbacks?.onProgress?.(`Updating existing records (${updated + 1}/${existingRecordsToUpdate.length})`);
-                // Create backup if configured (only once per file)
-                if (entityConfig.pull?.backupBeforeUpdate && !backedUpFiles.has(filePath)) {
-                    await this.createBackup(filePath, entityConfig.pull?.backupDirectory);
-                    backedUpFiles.add(filePath);
-                }
-                // Load existing file data
-                const existingData = await fs_extra_1.default.readJson(filePath);
-                // Find the specific existing record that matches this primary key
-                let existingRecordData;
-                if (Array.isArray(existingData)) {
-                    // Find the matching record in the array
-                    const matchingRecord = existingData.find(r => this.createPrimaryKeyLookup(r.primaryKey || {}) === this.createPrimaryKeyLookup(primaryKey));
-                    existingRecordData = matchingRecord || existingData[0]; // Fallback to first if not found
-                }
-                else {
-                    existingRecordData = existingData;
-                }
-                // Process the new record data (isNewRecord = false for updates)
-                const newRecordData = await this.processRecordData(record, primaryKey, targetDir, entityConfig, options.verbose, false, existingRecordData);
-                // Apply merge strategy
-                const mergedData = await this.mergeRecords(existingRecordData, newRecordData, entityConfig.pull?.mergeStrategy || 'merge', entityConfig.pull?.preserveFields || []);
-                // Write updated data
-                if (Array.isArray(existingData)) {
-                    // Update the record in the array
-                    const index = existingData.findIndex(r => this.createPrimaryKeyLookup(r.primaryKey || {}) === this.createPrimaryKeyLookup(primaryKey));
-                    if (index >= 0) {
-                        existingData[index] = mergedData;
-                        await fs_extra_1.default.writeJson(filePath, existingData, { spaces: 2 });
+        const errors = [];
+        // Process existing records updates in parallel
+        if (existingRecordsToUpdate.length > 0) {
+            callbacks?.onProgress?.(`Updating existing records (parallel processing)`);
+            const updatePromises = existingRecordsToUpdate.map(async ({ record, primaryKey, filePath }, index) => {
+                try {
+                    // Create backup if configured (only once per file)
+                    if (entityConfig.pull?.backupBeforeUpdate && !backedUpFiles.has(filePath)) {
+                        await this.createBackup(filePath, entityConfig.pull?.backupDirectory);
+                        backedUpFiles.add(filePath);
                     }
+                    // Load existing file data
+                    const existingData = await fs_extra_1.default.readJson(filePath);
+                    // Find the specific existing record that matches this primary key
+                    let existingRecordData;
+                    if (Array.isArray(existingData)) {
+                        // Find the matching record in the array
+                        const matchingRecord = existingData.find(r => this.createPrimaryKeyLookup(r.primaryKey || {}) === this.createPrimaryKeyLookup(primaryKey));
+                        existingRecordData = matchingRecord || existingData[0]; // Fallback to first if not found
+                    }
+                    else {
+                        existingRecordData = existingData;
+                    }
+                    // Process the new record data (isNewRecord = false for updates)
+                    const newRecordData = await this.recordProcessor.processRecord(record, primaryKey, targetDir, entityConfig, options.verbose, false, existingRecordData);
+                    // Apply merge strategy
+                    const mergedData = await this.mergeRecords(existingRecordData, newRecordData, entityConfig.pull?.mergeStrategy || 'merge', entityConfig.pull?.preserveFields || []);
+                    // Queue updated data for batched write
+                    if (Array.isArray(existingData)) {
+                        // Queue array update - batch will handle merging
+                        const primaryKeyLookup = this.createPrimaryKeyLookup(primaryKey);
+                        this.fileWriteBatch.queueArrayUpdate(filePath, mergedData, primaryKeyLookup);
+                    }
+                    else {
+                        // Queue single record update
+                        this.fileWriteBatch.queueSingleUpdate(filePath, mergedData);
+                    }
+                    if (options.verbose) {
+                        callbacks?.onLog?.(`Updated: ${filePath}`);
+                    }
+                    return { success: true, index };
                 }
-                else {
-                    await fs_extra_1.default.writeJson(filePath, mergedData, { spaces: 2 });
-                }
-                updated++;
-                processed++;
-                if (options.verbose) {
-                    callbacks?.onLog?.(`Updated: ${filePath}`);
+                catch (error) {
+                    const errorMessage = `Failed to update record ${index + 1}: ${error.message || error}`;
+                    errors.push(errorMessage);
+                    callbacks?.onWarn?.(errorMessage);
+                    return { success: false, index };
                 }
-            }
-            catch (error) {
-                callbacks?.onWarn?.(`Failed to update record: ${error.message || error}`);
+            });
+            const updateResults = await Promise.all(updatePromises);
+            updated = updateResults.filter(r => r.success).length;
+            processed += updated;
+            if (options.verbose) {
+                callbacks?.onSuccess?.(`Completed ${updated}/${existingRecordsToUpdate.length} record updates`);
             }
         }
-        // Process new records
+        // Process new records in parallel
         if (newRecords.length > 0) {
-            callbacks?.onProgress?.(`Creating new records (0/${newRecords.length})`);
+            callbacks?.onProgress?.(`Creating new records (parallel processing)`);
             if (entityConfig.pull?.appendRecordsToExistingFile && entityConfig.pull?.newFileName) {
-                // Append all new records to a single file
+                // Append all new records to a single file using parallel processing
                 const fileName = entityConfig.pull.newFileName.endsWith('.json')
                     ? entityConfig.pull.newFileName
                     : `${entityConfig.pull.newFileName}.json`;
                 const filePath = path_1.default.join(targetDir, fileName);
-                // Load existing file if it exists
-                let existingData = [];
-                if (await fs_extra_1.default.pathExists(filePath)) {
-                    const fileData = await fs_extra_1.default.readJson(filePath);
-                    existingData = Array.isArray(fileData) ? fileData : [fileData];
-                }
-                // Process and append all new records
-                for (const { record, primaryKey } of newRecords) {
+                // Process all new records in parallel
+                const newRecordPromises = newRecords.map(async ({ record, primaryKey }, index) => {
                     try {
                         // For new records, pass isNewRecord = true (default)
-                        const recordData = await this.processRecordData(record, primaryKey, targetDir, entityConfig, options.verbose, true);
-                        existingData.push(recordData);
-                        created++;
-                        processed++;
-                        if (options.verbose) {
-                            callbacks?.onProgress?.(`Creating new records (${created}/${newRecords.length})`);
-                        }
+                        const recordData = await this.recordProcessor.processRecord(record, primaryKey, targetDir, entityConfig, options.verbose, true);
+                        // Use queueArrayUpdate to append the new record without overwriting existing updates
+                        // For new records, we can use a special lookup key since they don't exist yet
+                        const newRecordLookup = this.createPrimaryKeyLookup(primaryKey);
+                        this.fileWriteBatch.queueArrayUpdate(filePath, recordData, newRecordLookup);
+                        return { success: true, index };
                     }
                     catch (error) {
-                        callbacks?.onWarn?.(`Failed to process new record: ${error.message || error}`);
+                        const errorMessage = `Failed to process new record ${index + 1}: ${error.message || error}`;
+                        errors.push(errorMessage);
+                        callbacks?.onWarn?.(errorMessage);
+                        return { success: false, index };
                     }
-                }
-                // Write the combined data
-                await fs_extra_1.default.writeJson(filePath, existingData, { spaces: 2 });
+                });
+                const newRecordResults = await Promise.all(newRecordPromises);
+                created = newRecordResults.filter(r => r.success).length;
+                processed += created;
                 if (options.verbose) {
-                    callbacks?.onLog?.(`Appended ${created} new records to: ${filePath}`);
+                    callbacks?.onLog?.(`Queued ${created} new records for: ${filePath}`);
                 }
             }
             else {
-                // Create individual files for each new record
-                for (const { record, primaryKey } of newRecords) {
+                // Create individual files for each new record in parallel
+                const individualRecordPromises = newRecords.map(async ({ record, primaryKey }, index) => {
                     try {
                         await this.processRecord(record, primaryKey, targetDir, entityConfig, options.verbose);
-                        created++;
-                        processed++;
-                        if (options.verbose) {
-                            callbacks?.onProgress?.(`Creating new records (${created}/${newRecords.length})`);
-                        }
+                        return { success: true, index };
                     }
                     catch (error) {
-                        callbacks?.onWarn?.(`Failed to process new record: ${error.message || error}`);
+                        const errorMessage = `Failed to process new record ${index + 1}: ${error.message || error}`;
+                        errors.push(errorMessage);
+                        callbacks?.onWarn?.(errorMessage);
+                        return { success: false, index };
                     }
+                });
+                const individualResults = await Promise.all(individualRecordPromises);
+                created = individualResults.filter(r => r.success).length;
+                processed += created;
+                if (options.verbose) {
+                    callbacks?.onSuccess?.(`Created ${created}/${newRecords.length} individual record files`);
                 }
             }
         }
+        // If there were errors during parallel processing, throw them
+        if (errors.length > 0) {
+            throw new Error(`Parallel processing completed with ${errors.length} errors:\n${errors.join('\n')}`);
+        }
         return { processed, updated, created, skipped };
     }
     async processRecord(record, primaryKey, targetDir, entityConfig, verbose) {
-        const recordData = await this.processRecordData(record, primaryKey, targetDir, entityConfig, verbose, true);
+        const recordData = await this.recordProcessor.processRecord(record, primaryKey, targetDir, entityConfig, verbose, true);
         // Determine file path
         const fileName = this.buildFileName(primaryKey, entityConfig);
         const filePath = path_1.default.join(targetDir, fileName);
-        // Write JSON file
-        await fs_extra_1.default.writeJson(filePath, recordData, { spaces: 2 });
-    }
-    async processRecordData(record, primaryKey, targetDir, entityConfig, verbose, isNewRecord = true, existingRecordData, currentDepth = 0, ancestryPath = new Set()) {
-        // This is a simplified version - the full implementation would need to be extracted
-        // from the pull command. For now, we'll delegate to a method that would be
-        // implemented in the full service
-        // Build record data
-        const fields = {};
-        const relatedEntities = {};
-        // Get the underlying data from the entity object
-        let dataToProcess = record;
-        if (typeof record.GetAll === 'function') {
-            dataToProcess = record.GetAll();
-        }
-        // Process fields (simplified - full implementation needed)
-        for (const [fieldName, fieldValue] of Object.entries(dataToProcess)) {
-            // Skip primary key fields
-            if (primaryKey[fieldName] !== undefined) {
-                continue;
-            }
-            // Skip internal fields
-            if (fieldName.startsWith('__mj_')) {
-                continue;
-            }
-            // Skip excluded fields
-            if (entityConfig.pull?.excludeFields?.includes(fieldName)) {
-                continue;
-            }
-            fields[fieldName] = fieldValue;
-        }
-        // Calculate checksum
-        const checksum = this.syncEngine.calculateChecksum(fields);
-        // Build the final record data
-        const recordData = {
-            fields,
-            primaryKey,
-            sync: {
-                lastModified: new Date().toISOString(),
-                checksum: checksum
-            }
-        };
-        if (Object.keys(relatedEntities).length > 0) {
-            recordData.relatedEntities = relatedEntities;
-        }
-        return recordData;
+        // Queue JSON file for batched write with controlled property order
+        this.fileWriteBatch.queueWrite(filePath, recordData);
     }
     async findEntityDirectories(entityName) {
         const dirs = [];
@@ -428,7 +519,7 @@ class PullService {
         await searchDirs(config_manager_1.configManager.getOriginalCwd());
         return dirs;
     }
-    buildFileName(primaryKey, entityConfig) {
+    buildFileName(primaryKey, _entityConfig) {
         // Use primary key values to build filename
         const keys = Object.values(primaryKey);
         if (keys.length === 1 && typeof keys[0] === 'string') {
@@ -474,7 +565,7 @@ class PullService {
         }
         return files;
     }
-    async loadExistingRecords(files, entityInfo) {
+    async loadExistingRecords(files, _entityInfo) {
         const recordsMap = new Map();
         for (const filePath of files) {
             try {
@@ -548,12 +639,16 @@ class PullService {
         const backupDir = path_1.default.join(dir, backupDirName || '.backups');
         // Ensure backup directory exists
         await fs_extra_1.default.ensureDir(backupDir);
+        // Track the backup directory for cleanup
+        this.createdBackupDirs.add(backupDir);
         const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
         // Remove .json extension, add timestamp, then add .backup extension
         const backupFileName = fileName.replace(/\.json$/, `.${timestamp}.backup`);
         const backupPath = path_1.default.join(backupDir, backupFileName);
         try {
             await fs_extra_1.default.copy(filePath, backupPath);
+            // Track the created backup file for cleanup
+            this.createdBackupFiles.push(backupPath);
         }
         catch (error) {
             // Log error but don't throw