@contentstack/cli-variants 1.3.3 → 2.0.0-beta

package/src/export/audiences.ts

@@ -1,73 +1,99 @@
 import omit from 'lodash/omit';
 import { resolve as pResolve } from 'node:path';
-import { log, handleAndLogError } from '@contentstack/cli-utilities';
-
+import { sanitizePath, log, handleAndLogError } from '@contentstack/cli-utilities';
+import { PersonalizeConfig, ExportConfig, AudiencesConfig, AudienceStruct } from '../types';
 import { fsUtil, PersonalizationAdapter } from '../utils';
-import { PersonalizeConfig, ExportConfig, AudienceStruct, AudiencesConfig } from '../types';
+import { PROCESS_NAMES, MODULE_CONTEXTS, EXPORT_PROCESS_STATUS } from '../utils/constants';
 
 export default class ExportAudiences extends PersonalizationAdapter<ExportConfig> {
   private audiencesConfig: AudiencesConfig;
   private audiencesFolderPath: string;
   private audiences: Record<string, unknown>[];
+  public exportConfig: ExportConfig;
   public personalizeConfig: PersonalizeConfig;
 
-  constructor(readonly exportConfig: ExportConfig) {
+  constructor(exportConfig: ExportConfig) {
     super({
       config: exportConfig,
       baseURL: exportConfig.modules.personalize.baseURL[exportConfig.region.name],
       headers: { 'X-Project-Uid': exportConfig.project_id },
     });
+    this.exportConfig = exportConfig;
     this.personalizeConfig = exportConfig.modules.personalize;
     this.audiencesConfig = exportConfig.modules.audiences;
     this.audiencesFolderPath = pResolve(
-      exportConfig.data,
-      exportConfig.branchName || '',
-      this.personalizeConfig.dirName,
-      this.audiencesConfig.dirName,
+      sanitizePath(exportConfig.data),
+      sanitizePath(exportConfig.branchName || ''),
+      sanitizePath(this.personalizeConfig.dirName),
+      sanitizePath(this.audiencesConfig.dirName),
     );
     this.audiences = [];
-    this.exportConfig.context.module = 'audiences';
+    this.exportConfig.context.module = MODULE_CONTEXTS.AUDIENCES;
   }
 
   async start() {
     try {
       log.debug('Starting audiences export process...', this.exportConfig.context);
       log.info('Starting audiences export', this.exportConfig.context);
-      
-      log.debug('Initializing personalization adapter...', this.exportConfig.context);
-      await this.init();
-      log.debug('Personalization adapter initialized successfully', this.exportConfig.context);
-      
-      log.debug(`Creating audiences directory at: ${this.audiencesFolderPath}`, this.exportConfig.context);
-      await fsUtil.makeDirectory(this.audiencesFolderPath);
-      log.debug('Audiences directory created successfully', this.exportConfig.context);
-      
-      log.debug('Fetching audiences from personalization API...', this.exportConfig.context);
-      this.audiences = (await this.getAudiences()) as AudienceStruct[];
-      log.debug(`Fetched ${this.audiences?.length || 0} audiences`, this.exportConfig.context);
+
+      await this.withLoadingSpinner('AUDIENCES: Initializing export and fetching data...', async () => {
+        log.debug('Initializing personalization adapter...', this.exportConfig.context);
+        await this.init();
+        log.debug('Personalization adapter initialized successfully', this.exportConfig.context);
+
+        log.debug(`Creating audiences directory at: ${this.audiencesFolderPath}`, this.exportConfig.context);
+        await fsUtil.makeDirectory(this.audiencesFolderPath);
+        log.debug('Audiences directory created successfully', this.exportConfig.context);
+
+        log.debug('Fetching audiences from personalization API...', this.exportConfig.context);
+        this.audiences = (await this.getAudiences()) as AudienceStruct[];
+        log.debug(`Fetched ${this.audiences?.length || 0} audiences`, this.exportConfig.context);
+      });
 
       if (!this.audiences?.length) {
         log.debug('No audiences found, completing export', this.exportConfig.context);
         log.info('No Audiences found with the given project!', this.exportConfig.context);
         return;
+      }
+
+      let progress: any;
+
+      if (this.parentProgressManager) {
+        progress = this.parentProgressManager;
+        this.progressManager = this.parentProgressManager;
+        progress.updateProcessTotal(PROCESS_NAMES.AUDIENCES, this.audiences.length);
       } else {
-        log.debug(`Processing ${this.audiences.length} audiences`, this.exportConfig.context);
-        this.sanitizeAttribs();
-        log.debug('Audiences sanitization completed', this.exportConfig.context);
-        
-        const audiencesFilePath = pResolve(this.audiencesFolderPath, this.audiencesConfig.fileName);
-        log.debug(`Writing audiences to: ${audiencesFilePath}`, this.exportConfig.context);
-        fsUtil.writeFile(audiencesFilePath, this.audiences);
-        
-        log.debug('Audiences export completed successfully', this.exportConfig.context);
-        log.success(
-          `Audiences exported successfully! Total audiences: ${this.audiences.length}`,
-          this.exportConfig.context,
-        );
-        return;
+        progress = this.createSimpleProgress(PROCESS_NAMES.AUDIENCES, this.audiences.length);
       }
-    } catch (error) {
+
+      log.debug(`Processing ${this.audiences.length} audiences`, this.exportConfig.context);
+      progress.updateStatus(EXPORT_PROCESS_STATUS[PROCESS_NAMES.AUDIENCES].EXPORTING, PROCESS_NAMES.AUDIENCES);
+
+      this.sanitizeAttribs();
+      log.debug('Audiences sanitization completed', this.exportConfig.context);
+
+      // Write audiences to file
+      progress.updateStatus(EXPORT_PROCESS_STATUS[PROCESS_NAMES.AUDIENCES].EXPORTING, PROCESS_NAMES.AUDIENCES);
+      const audiencesFilePath = pResolve(
+        sanitizePath(this.audiencesFolderPath),
+        sanitizePath(this.audiencesConfig.fileName),
+      );
+      log.debug(`Writing audiences to: ${audiencesFilePath}`, this.exportConfig.context);
+      fsUtil.writeFile(audiencesFilePath, this.audiences);
+
+      // Complete progress only if we're managing our own progress
+      if (!this.parentProgressManager) {
+        this.completeProgress(true);
+      }
+
+      log.debug('Audiences export completed successfully', this.exportConfig.context);
+      log.success(
+        `Audiences exported successfully! Total audiences: ${this.audiences.length}`,
+        this.exportConfig.context,
+      );
+    } catch (error: any) {
       log.debug(`Error occurred during audiences export: ${error}`, this.exportConfig.context);
+      this.completeProgress(false, error?.message || 'Audiences export failed');
       handleAndLogError(error, { ...this.exportConfig.context });
     }
   }
@@ -77,10 +103,30 @@ export default class ExportAudiences extends PersonalizationAdapter<ExportConfig
    */
   sanitizeAttribs() {
     log.debug(`Sanitizing ${this.audiences?.length || 0} audiences`, this.exportConfig.context);
-    log.debug(`Invalid keys to remove: ${JSON.stringify(this.audiencesConfig.invalidKeys)}`, this.exportConfig.context);
-    
-    this.audiences = this.audiences?.map((audience) => omit(audience, this.audiencesConfig.invalidKeys)) || [];
-    
-    log.debug(`Sanitization complete. Total audiences after sanitization: ${this.audiences.length}`, this.exportConfig.context);
+
+    this.audiences =
+      this.audiences?.map((audience, index) => {
+        const sanitizedAudience = omit(audience, this.audiencesConfig.invalidKeys);
+
+        // Update progress for each processed audience
+        if (this.progressManager) {
+          const processName = this.parentProgressManager ? PROCESS_NAMES.AUDIENCES : undefined;
+          this.updateProgress(
+            true,
+            `audience ${index + 1}/${this.audiences.length}: ${
+              (audience as any).name || (audience as any).uid || 'unknown'
+            }`,
+            undefined,
+            processName,
+          );
+        }
+
+        return sanitizedAudience;
+      }) || [];
+
+    log.debug(
+      `Sanitization complete. Total audiences after sanitization: ${this.audiences.length}`,
+      this.exportConfig.context,
+    );
   }
 }

package/src/export/events.ts

@@ -1,73 +1,97 @@
 import omit from 'lodash/omit';
 import { resolve as pResolve } from 'node:path';
-import { log, handleAndLogError } from '@contentstack/cli-utilities';
-
+import { sanitizePath, log, handleAndLogError } from '@contentstack/cli-utilities';
+import { PersonalizeConfig, ExportConfig, EventsConfig, EventStruct } from '../types';
 import { fsUtil, PersonalizationAdapter } from '../utils';
-import { PersonalizeConfig, ExportConfig, EventStruct, EventsConfig } from '../types';
+import { PROCESS_NAMES, MODULE_CONTEXTS, EXPORT_PROCESS_STATUS } from '../utils/constants';
 
 export default class ExportEvents extends PersonalizationAdapter<ExportConfig> {
   private eventsConfig: EventsConfig;
   private eventsFolderPath: string;
   private events: Record<string, unknown>[];
+  public exportConfig: ExportConfig;
   public personalizeConfig: PersonalizeConfig;
 
-  constructor(readonly exportConfig: ExportConfig) {
+  constructor(exportConfig: ExportConfig) {
     super({
       config: exportConfig,
       baseURL: exportConfig.modules.personalize.baseURL[exportConfig.region.name],
       headers: { 'X-Project-Uid': exportConfig.project_id },
     });
+    this.exportConfig = exportConfig;
     this.personalizeConfig = exportConfig.modules.personalize;
     this.eventsConfig = exportConfig.modules.events;
     this.eventsFolderPath = pResolve(
-      exportConfig.data,
-      exportConfig.branchName || '',
-      this.personalizeConfig.dirName,
-      this.eventsConfig.dirName,
+      sanitizePath(exportConfig.data),
+      sanitizePath(exportConfig.branchName || ''),
+      sanitizePath(this.personalizeConfig.dirName),
+      sanitizePath(this.eventsConfig.dirName),
     );
     this.events = [];
-    this.exportConfig.context.module = 'events';
+    this.exportConfig.context.module = MODULE_CONTEXTS.EVENTS;
   }
 
   async start() {
     try {
       log.debug('Starting events export process...', this.exportConfig.context);
       log.info('Starting events export', this.exportConfig.context);
-      
-      log.debug('Initializing personalization adapter...', this.exportConfig.context);
-      await this.init();
-      log.debug('Personalization adapter initialized successfully', this.exportConfig.context);
-      
-      log.debug(`Creating events directory at: ${this.eventsFolderPath}`, this.exportConfig.context);
-      await fsUtil.makeDirectory(this.eventsFolderPath);
-      log.debug('Events directory created successfully', this.exportConfig.context);
-      
-      log.debug('Fetching events from personalization API...', this.exportConfig.context);
-      this.events = (await this.getEvents()) as EventStruct[];
-      log.debug(`Fetched ${this.events?.length || 0} events`, this.exportConfig.context);
+
+      await this.withLoadingSpinner('EVENTS: Initializing export and fetching data...', async () => {
+        log.debug('Initializing personalization adapter...', this.exportConfig.context);
+        await this.init();
+        log.debug('Personalization adapter initialized successfully', this.exportConfig.context);
+
+        log.debug(`Creating events directory at: ${this.eventsFolderPath}`, this.exportConfig.context);
+        await fsUtil.makeDirectory(this.eventsFolderPath);
+        log.debug('Events directory created successfully', this.exportConfig.context);
+
+        log.debug('Fetching events from personalization API...', this.exportConfig.context);
+        this.events = (await this.getEvents()) as EventStruct[];
+        log.debug(`Fetched ${this.events?.length || 0} events`, this.exportConfig.context);
+      });
 
       if (!this.events?.length) {
         log.debug('No events found, completing export', this.exportConfig.context);
         log.info('No Events found with the given project!', this.exportConfig.context);
         return;
+      }
+
+      let progress: any;
+
+      if (this.parentProgressManager) {
+        progress = this.parentProgressManager;
+        this.progressManager = this.parentProgressManager;
+        progress.updateProcessTotal(PROCESS_NAMES.EVENTS, this.events.length);
       } else {
-        log.debug(`Processing ${this.events.length} events`, this.exportConfig.context);
-        this.sanitizeAttribs();
-        log.debug('Events sanitization completed', this.exportConfig.context);
-        
-        const eventsFilePath = pResolve(this.eventsFolderPath, this.eventsConfig.fileName);
-        log.debug(`Writing events to: ${eventsFilePath}`, this.exportConfig.context);
-        fsUtil.writeFile(eventsFilePath, this.events);
-        
-        log.debug('Events export completed successfully', this.exportConfig.context);
-        log.success(
-          `Events exported successfully! Total events: ${this.events.length}`,
-          this.exportConfig.context,
-        );
-        return;
+        progress = this.createSimpleProgress(PROCESS_NAMES.EVENTS, this.events.length);
       }
-    } catch (error) {
+
+      log.debug(`Processing ${this.events.length} events`, this.exportConfig.context);
+      progress.updateStatus(EXPORT_PROCESS_STATUS[PROCESS_NAMES.EVENTS].EXPORTING, PROCESS_NAMES.EVENTS);
+
+      this.sanitizeAttribs();
+      log.debug('Events sanitization completed', this.exportConfig.context);
+
+      progress.updateStatus(EXPORT_PROCESS_STATUS[PROCESS_NAMES.EVENTS].EXPORTING, PROCESS_NAMES.EVENTS);
+      const eventsFilePath = pResolve(sanitizePath(this.eventsFolderPath), sanitizePath(this.eventsConfig.fileName));
+      log.debug(`Writing events to: ${eventsFilePath}`, this.exportConfig.context);
+      fsUtil.writeFile(eventsFilePath, this.events);
+
+      // Final progress update
+      if (this.progressManager) {
+        //this.updateProgress(true, `${this.events.length} events exported`, undefined, processName);
+      }
+
+      // Complete progress only if we're managing our own progress
+      if (!this.parentProgressManager) {
+        this.completeProgress(true);
+      }
+
+      log.debug('Events export completed successfully', this.exportConfig.context);
+      log.success(`Events exported successfully! Total events: ${this.events.length}`, this.exportConfig.context);
+    } catch (error: any) {
       log.debug(`Error occurred during events export: ${error}`, this.exportConfig.context);
+      this.completeProgress(false, error?.message || 'Events export failed');
       handleAndLogError(error, { ...this.exportConfig.context });
     }
   }
@@ -77,10 +101,29 @@ export default class ExportEvents extends PersonalizationAdapter<ExportConfig> {
    */
   sanitizeAttribs() {
     log.debug(`Sanitizing ${this.events?.length || 0} events`, this.exportConfig.context);
-    log.debug(`Invalid keys to remove: ${JSON.stringify(this.eventsConfig.invalidKeys)}`, this.exportConfig.context);
-    
-    this.events = this.events?.map((event) => omit(event, this.eventsConfig.invalidKeys)) || [];
-    
-    log.debug(`Sanitization complete. Total events after sanitization: ${this.events.length}`, this.exportConfig.context);
+
+    this.events =
+      this.events?.map((event, index) => {
+        const sanitizedEvent = omit(event, this.eventsConfig.invalidKeys);
+
+        if (this.progressManager) {
+          const processName = this.parentProgressManager ? PROCESS_NAMES.EVENTS : undefined;
+          this.updateProgress(
+            true,
+            `event ${index + 1}/${this.events.length}: ${
+              (event as any).key || (event as any).name || (event as any).uid || 'unknown'
+            }`,
+            undefined,
+            processName,
+          );
+        }
+
+        return sanitizedEvent;
+      }) || [];
+
+    log.debug(
+      `Sanitization complete. Total events after sanitization: ${this.events.length}`,
+      this.exportConfig.context,
+    );
   }
 }

package/src/export/experiences.ts

@@ -2,11 +2,13 @@ import * as path from 'path';
 import { sanitizePath, log, handleAndLogError } from '@contentstack/cli-utilities';
 import { PersonalizeConfig, ExportConfig, ExperienceStruct } from '../types';
 import { fsUtil, PersonalizationAdapter } from '../utils';
+import { PROCESS_NAMES, MODULE_CONTEXTS, EXPORT_PROCESS_STATUS } from '../utils/constants';
 
 export default class ExportExperiences extends PersonalizationAdapter<ExportConfig> {
   private experiencesFolderPath: string;
   public exportConfig: ExportConfig;
   public personalizeConfig: PersonalizeConfig;
+
   constructor(exportConfig: ExportConfig) {
     super({
       config: exportConfig,
@@ -25,123 +27,193 @@ export default class ExportExperiences extends PersonalizationAdapter<ExportConf
       sanitizePath(this.personalizeConfig.dirName),
       'experiences',
     );
-    this.exportConfig.context.module = 'experiences';
+    this.exportConfig.context.module = MODULE_CONTEXTS.EXPERIENCES;
   }
 
   async start() {
     try {
-      // get all experiences
-      // loop through experiences and get content types attached to it
-      // write experiences in to a file
       log.debug('Starting experiences export process...', this.exportConfig.context);
       log.info('Starting experiences export', this.exportConfig.context);
-      
-      log.debug('Initializing personalization adapter...', this.exportConfig.context);
-      await this.init();
-      log.debug('Personalization adapter initialized successfully', this.exportConfig.context);
-      
-      log.debug(`Creating experiences directory at: ${this.experiencesFolderPath}`, this.exportConfig.context);
-      await fsUtil.makeDirectory(this.experiencesFolderPath);
-      log.debug('Experiences directory created successfully', this.exportConfig.context);
-      
-      const versionsDirPath = path.resolve(sanitizePath(this.experiencesFolderPath), 'versions');
-      log.debug(`Creating versions directory at: ${versionsDirPath}`, this.exportConfig.context);
-      await fsUtil.makeDirectory(versionsDirPath);
-      log.debug('Versions directory created successfully', this.exportConfig.context);
-      
-      log.debug('Fetching experiences from personalization API...', this.exportConfig.context);
-      const experiences: Array<ExperienceStruct> = (await this.getExperiences()) || [];
-      log.debug(`Fetched ${experiences?.length || 0} experiences`, this.exportConfig.context);
-      
+
+      const { experiences } = await this.withLoadingSpinner(
+        'EXPERIENCES: Initializing export and fetching data...',
+        async () => {
+          log.debug('Initializing personalization adapter...', this.exportConfig.context);
+          await this.init();
+          log.debug('Personalization adapter initialized successfully', this.exportConfig.context);
+
+          log.debug(`Creating experiences directory at: ${this.experiencesFolderPath}`, this.exportConfig.context);
+          await fsUtil.makeDirectory(this.experiencesFolderPath);
+          log.debug('Experiences directory created successfully', this.exportConfig.context);
+
+          const versionsDirPath = path.resolve(sanitizePath(this.experiencesFolderPath), 'versions');
+          log.debug(`Creating versions directory at: ${versionsDirPath}`, this.exportConfig.context);
+          await fsUtil.makeDirectory(versionsDirPath);
+          log.debug('Versions directory created successfully', this.exportConfig.context);
+
+          log.debug('Fetching experiences from personalization API...', this.exportConfig.context);
+          const experiences: Array<ExperienceStruct> = (await this.getExperiences()) || [];
+          log.debug(`Fetched ${experiences?.length || 0} experiences`, this.exportConfig.context);
+
+          return { experiences };
+        },
+      );
+
       if (!experiences || experiences?.length < 1) {
         log.debug('No experiences found, completing export', this.exportConfig.context);
         log.info('No Experiences found with the given project!', this.exportConfig.context);
         return;
       }
-      
+
+      let progress: any;
+      const processName = PROCESS_NAMES.EXPERIENCES;
+
+      if (this.parentProgressManager) {
+        progress = this.parentProgressManager;
+        this.progressManager = this.parentProgressManager;
+        progress.updateProcessTotal(processName, experiences.length);
+      } else {
+        // Create our own progress for standalone execution
+        progress = this.createSimpleProgress(PROCESS_NAMES.EXPERIENCES, experiences.length);
+      }
+
+      log.debug(`Processing ${experiences.length} experiences`, this.exportConfig.context);
+      progress.updateStatus(EXPORT_PROCESS_STATUS[PROCESS_NAMES.EXPERIENCES].EXPORTING, processName);
+
       const experiencesFilePath = path.resolve(sanitizePath(this.experiencesFolderPath), 'experiences.json');
       log.debug(`Writing experiences to: ${experiencesFilePath}`, this.exportConfig.context);
       fsUtil.writeFile(experiencesFilePath, experiences);
 
       const experienceToVariantsStrList: Array<string> = [];
       const experienceToContentTypesMap: Record<string, string[]> = {};
-      
-      log.debug(`Processing ${experiences.length} experiences for variants and content types`, this.exportConfig.context);
-      
-      for (let experience of experiences) {
-        log.debug(`Processing experience: ${experience.name} (${experience.uid})`, this.exportConfig.context);
-        
-        // create id mapper for experience to variants
-        let variants = experience?._cms?.variants ?? {};
-        log.debug(`Found ${Object.keys(variants).length} variants for experience: ${experience.name}`, this.exportConfig.context);
-        
-        Object.keys(variants).forEach((variantShortId: string) => {
-          const experienceToVariantsStr = `${experience.uid}-${variantShortId}-${variants[variantShortId]}`;
-          experienceToVariantsStrList.push(experienceToVariantsStr);
-          log.debug(`Added variant mapping: ${experienceToVariantsStr}`, this.exportConfig.context);
-        });
 
+      log.debug(
+        `Processing ${experiences.length} experiences for variants and content types`,
+        this.exportConfig.context,
+      );
+
+      progress.updateStatus(EXPORT_PROCESS_STATUS[PROCESS_NAMES.EXPERIENCES].EXPORTING, processName);
+
+      for (let experienceIndex = 0; experienceIndex < experiences.length; experienceIndex++) {
+        const experience = experiences[experienceIndex];
         try {
-          // fetch versions of experience
-          log.debug(`Fetching versions for experience: ${experience.name}`, this.exportConfig.context);
-          const experienceVersions = (await this.getExperienceVersions(experience.uid)) || [];
-          log.debug(`Fetched ${experienceVersions.length} versions for experience: ${experience.name}`, this.exportConfig.context);
-          
-          if (experienceVersions.length > 0) {
-            const versionsFilePath = path.resolve(sanitizePath(this.experiencesFolderPath), 'versions', `${experience.uid}.json`);
-            log.debug(`Writing experience versions to: ${versionsFilePath}`, this.exportConfig.context);
-            fsUtil.writeFile(versionsFilePath, experienceVersions);
-          } else {
-            log.debug(`No versions found for experience: ${experience.name}`, this.exportConfig.context);
-            log.info(
-              `No versions found for experience '${experience.name}'`,
+          log.debug(
+            `Processing experience: ${experience.name} (${experience.uid}) - ${experienceIndex + 1}/${
+              experiences.length
+            }`,
+            this.exportConfig.context,
+          );
+
+          // create id mapper for experience to variants
+          let variants = experience?._cms?.variants ?? {};
+          // talisman-ignore-start
+          log.debug(
+            `Found ${Object.keys(variants).length} variants for experience: ${experience.name}`,
+            this.exportConfig.context,
+          );
+          // talisman-ignore-end
+
+          // talisman-ignore-start
+          Object.keys(variants).forEach((variantShortId: string) => {
+            const experienceToVariantsStr = `${experience.uid}-${variantShortId}-${variants[variantShortId]}`;
+            experienceToVariantsStrList.push(experienceToVariantsStr);
+            log.debug(`Added variant mapping: ${experienceToVariantsStr}`, this.exportConfig.context);
+          });
+          // talisman-ignore-end
+
+          // Fetch versions of experience
+          try {
+            log.debug(`Fetching versions for experience: ${experience.name}`, this.exportConfig.context);
+            const experienceVersions = (await this.getExperienceVersions(experience.uid)) || [];
+            log.debug(
+              `Fetched ${experienceVersions.length} versions for experience: ${experience.name}`,
               this.exportConfig.context,
             );
+
+            if (experienceVersions.length > 0) {
+              const versionsFilePath = path.resolve(
+                sanitizePath(this.experiencesFolderPath),
+                'versions',
+                `${experience.uid}.json`,
+              );
+              log.debug(`Writing experience versions to: ${versionsFilePath}`, this.exportConfig.context);
+              fsUtil.writeFile(versionsFilePath, experienceVersions);
+            } else {
+              log.debug(`No versions found for experience: ${experience.name}`, this.exportConfig.context);
+              log.info(`No versions found for experience '${experience.name}'`, this.exportConfig.context);
+            }
+          } catch (error: any) {
+            log.debug(
+              `Error occurred while fetching versions for experience: ${experience.name}`,
+              this.exportConfig.context,
+            );
+            handleAndLogError(
+              error,
+              { ...this.exportConfig.context },
+              `Failed to fetch versions of experience ${experience.name}`,
+            );
           }
-        } catch (error) {
-          log.debug(`Error occurred while fetching versions for experience: ${experience.name}`, this.exportConfig.context);
-          handleAndLogError(
-            error,
-            {...this.exportConfig.context},
-            `Failed to fetch versions of experience ${experience.name}`
-          );
-        }
 
-        try {
-          // fetch content of experience
-          log.debug(`Fetching variant group for experience: ${experience.name}`, this.exportConfig.context);
-          const { variant_groups: [variantGroup] = [] } =
-            (await this.getVariantGroup({ experienceUid: experience.uid })) || {};
-          
-          if (variantGroup?.content_types?.length) {
-            log.debug(`Found ${variantGroup.content_types.length} content types for experience: ${experience.name}`, this.exportConfig.context);
-            experienceToContentTypesMap[experience.uid] = variantGroup.content_types;
-          } else {
-            log.debug(`No content types found for experience: ${experience.name}`, this.exportConfig.context);
+          // Fetch content types of experience
+          try {
+            log.debug(`Fetching variant group for experience: ${experience.name}`, this.exportConfig.context);
+            const { variant_groups: [variantGroup] = [] } =
+              (await this.getVariantGroup({ experienceUid: experience.uid })) || {};
+
+            if (variantGroup?.content_types?.length) {
+              log.debug(
+                `Found ${variantGroup.content_types.length} content types for experience: ${experience.name}`,
+                this.exportConfig.context,
+              );
+              experienceToContentTypesMap[experience.uid] = variantGroup.content_types;
+            } else {
+              log.debug(`No content types found for experience: ${experience.name}`, this.exportConfig.context);
+            }
+          } catch (error: any) {
+            log.debug(
+              `Error occurred while fetching content types for experience: ${experience.name}`,
+              this.exportConfig.context,
+            );
+            handleAndLogError(
+              error,
+              { ...this.exportConfig.context },
+              `Failed to fetch content types of experience ${experience.name}`,
+            );
           }
-        } catch (error) {
-          log.debug(`Error occurred while fetching content types for experience: ${experience.name}`, this.exportConfig.context);
-          handleAndLogError(
-            error,
-            {...this.exportConfig.context},
-            `Failed to fetch content types of experience ${experience.name}`
-          );
+        } catch (error: any) {
+          log.debug(`Error occurred while processing experience: ${experience.name}`, this.exportConfig.context);
+          handleAndLogError(error, { ...this.exportConfig.context }, `Failed to process experience ${experience.name}`);
         }
       }
-      
-      const variantsIdsFilePath = path.resolve(sanitizePath(this.experiencesFolderPath), 'experiences-variants-ids.json');
+
+      progress.updateStatus(EXPORT_PROCESS_STATUS[PROCESS_NAMES.EXPERIENCES].EXPORTING, processName);
+
+      // Write final mapping files
+      const variantsIdsFilePath = path.resolve(
+        sanitizePath(this.experiencesFolderPath),
+        'experiences-variants-ids.json',
+      );
       log.debug(`Writing experience variants mapping to: ${variantsIdsFilePath}`, this.exportConfig.context);
       fsUtil.writeFile(variantsIdsFilePath, experienceToVariantsStrList);
 
-      const contentTypesFilePath = path.resolve(sanitizePath(this.experiencesFolderPath), 'experiences-content-types.json');
+      const contentTypesFilePath = path.resolve(
+        sanitizePath(this.experiencesFolderPath),
+        'experiences-content-types.json',
+      );
       log.debug(`Writing experience content types mapping to: ${contentTypesFilePath}`, this.exportConfig.context);
       fsUtil.writeFile(contentTypesFilePath, experienceToContentTypesMap);
-      
+
+      // Complete progress only if we're managing our own progress
+      if (!this.parentProgressManager) {
+        this.completeProgress(true);
+      }
+
       log.debug('Experiences export completed successfully', this.exportConfig.context);
       log.success('Experiences exported successfully!', this.exportConfig.context);
-    } catch (error) {
+    } catch (error: any) {
       log.debug(`Error occurred during experiences export: ${error}`, this.exportConfig.context);
-      handleAndLogError(error, {...this.exportConfig.context});
+      this.completeProgress(false, error?.message || 'Experiences export failed');
+      handleAndLogError(error, { ...this.exportConfig.context });
     }
   }
 }