@contentstack/cli-variants 1.3.3 → 2.0.0-beta

package/src/import/experiences.ts

@@ -11,6 +11,7 @@ import {
   CreateExperienceInput,
   CreateExperienceVersionInput,
 } from '../types';
+import { PROCESS_NAMES, MODULE_CONTEXTS } from '../utils/constants';
 
 export default class Experiences extends PersonalizationAdapter<ImportConfig> {
   private createdCTs: string[];
@@ -40,9 +41,10 @@ export default class Experiences extends PersonalizationAdapter<ImportConfig> {
   private personalizeConfig: ImportConfig['modules']['personalize'];
   private audienceConfig: ImportConfig['modules']['personalize']['audiences'];
   private experienceConfig: ImportConfig['modules']['personalize']['experiences'];
+  private experiences: ExperienceStruct[];
 
   constructor(public readonly config: ImportConfig) {
-   const conf: APIConfig = {
+    const conf: APIConfig = {
       config,
       baseURL: config.modules.personalize.baseURL[config.region.name],
       headers: { 'X-Project-Uid': config.modules.personalize.project_id },
@@ -52,7 +54,7 @@ export default class Experiences extends PersonalizationAdapter<ImportConfig> {
       },
     };
     super(Object.assign(config, conf));
-    
+
     this.personalizeConfig = this.config.modules.personalize;
     this.experiencesDirPath = resolve(
       sanitizePath(this.config.data),
@@ -101,33 +103,55 @@ export default class Experiences extends PersonalizationAdapter<ImportConfig> {
     this.createdCTs = [];
     this.audiencesUid = (fsUtil.readFile(this.audiencesMapperPath, true) as Record<string, string>) || {};
     this.eventsUid = (fsUtil.readFile(this.eventsMapperPath, true) as Record<string, string>) || {};
-    this.config.context.module = 'experiences';
+    this.config.context.module = MODULE_CONTEXTS.EXPERIENCES;
+    this.experiences = [];
   }
 
   /**
    * The function asynchronously imports experiences from a JSON file and creates them in the system.
    */
-  async import() {   
-    await this.init();
-    await fsUtil.makeDirectory(this.expMapperDirPath);
-    log.debug(`Created mapper directory: ${this.expMapperDirPath}`, this.config.context);
-
-    if (existsSync(this.experiencesPath)) {
-      log.debug(`Loading experiences from: ${this.experiencesPath}`, this.config.context);
-      
-      try {
-        const experiences = fsUtil.readFile(this.experiencesPath, true) as ExperienceStruct[];
-        log.info(`Found ${experiences.length} experiences to import`, this.config.context);
-
-        for (const experience of experiences) {
-          const { uid, ...restExperienceData } = experience;
-          log.debug(`Processing experience: ${uid}`, this.config.context);
-          
-          //check whether reference audience exists or not that referenced in variations having __type equal to AudienceBasedVariation & targeting
-          let experienceReqObj: CreateExperienceInput = lookUpAudiences(restExperienceData, this.audiencesUid);
-          //check whether events exists or not that referenced in metrics
-          experienceReqObj = lookUpEvents(experienceReqObj, this.eventsUid);
+  async import() {
+    try {
+      log.debug('Starting experiences import...', this.config.context);
+
+      const [canImport, experiencesCount] = await this.analyzeExperiences();
+      if (!canImport) {
+        log.info('No experiences found to import', this.config.context);
+        // Still need to mark as complete for parent progress
+        if (this.parentProgressManager) {
+          this.parentProgressManager.tick(true, 'experiences module (no data)', null, PROCESS_NAMES.EXPERIENCES);
+        }
+        return;
+      }
+
+      // If we have a parent progress manager, use it as a sub-module
+      // Otherwise create our own simple progress manager
+      let progress;
+      if (this.parentProgressManager) {
+        progress = this.parentProgressManager;
+        log.debug('Using parent progress manager for experiences import', this.config.context);
+        this.parentProgressManager.updateProcessTotal(PROCESS_NAMES.EXPERIENCES, experiencesCount);
+      } else {
+        progress = this.createSimpleProgress(PROCESS_NAMES.EXPERIENCES, experiencesCount);
+        log.debug('Created standalone progress manager for experiences import', this.config.context);
+      }
+
+      await this.init();
+      await fsUtil.makeDirectory(this.expMapperDirPath);
+      log.debug(`Created mapper directory: ${this.expMapperDirPath}`, this.config.context);
+
+      log.info(`Processing ${experiencesCount} experiences for import`, this.config.context);
 
+      for (const experience of this.experiences) {
+        const { uid, ...restExperienceData } = experience;
+        log.debug(`Processing experience: ${uid}`, this.config.context);
+
+        //check whether reference audience exists or not that referenced in variations having __type equal to AudienceBasedVariation & targeting
+        let experienceReqObj: CreateExperienceInput = lookUpAudiences(restExperienceData, this.audiencesUid);
+        //check whether events exists or not that referenced in metrics
+        experienceReqObj = lookUpEvents(experienceReqObj, this.eventsUid);
+
+        try {
           const expRes = (await this.createExperience(experienceReqObj)) as ExperienceStruct;
           //map old experience uid to new experience uid
           this.experiencesUidMapper[uid] = expRes?.uid ?? '';
@@ -139,45 +163,90 @@ export default class Experiences extends PersonalizationAdapter<ImportConfig> {
           } catch (error) {
             handleAndLogError(error, this.config.context, `Failed to import experience versions for ${expRes.uid}`);
           }
-        }
-        
-        fsUtil.writeFile(this.experiencesUidMapperPath, this.experiencesUidMapper);
-        log.success('Experiences created successfully', this.config.context);
-
-        log.info('Validating variant and variant group creation',this.config.context);
-        this.pendingVariantAndVariantGrpForExperience = values(cloneDeep(this.experiencesUidMapper));
-        const jobRes = await this.validateVariantGroupAndVariantsCreated();
-        fsUtil.writeFile(this.cmsVariantPath, this.cmsVariants);
-        fsUtil.writeFile(this.cmsVariantGroupPath, this.cmsVariantGroups);
-        
-        if (jobRes) {
-          log.success('Variant and variant groups created successfully', this.config.context);
-        } else {
-          log.error('Failed to create variants and variant groups', this.config.context);
-          this.personalizeConfig.importData = false;
-        }
 
-        if (this.personalizeConfig.importData) {
-          log.info('Attaching content types to experiences', this.config.context);
-          await this.attachCTsInExperience();
-          log.success('Content types attached to experiences successfully', this.config.context);
+          this.updateProgress(true, `experience: ${experience.name || uid}`, undefined, PROCESS_NAMES.EXPERIENCES);
+          log.debug(`Successfully processed experience: ${uid}`, this.config.context);
+        } catch (error) {
+          this.updateProgress(
+            false,
+            `experience: ${experience.name || uid}`,
+            (error as any)?.message,
+            PROCESS_NAMES.EXPERIENCES,
+          );
+          handleAndLogError(error, this.config.context, `Failed to create experience: ${uid}`);
         }
+      }
 
-        await this.createVariantIdMapper();
-      } catch (error) {
-        handleAndLogError(error, this.config.context);
+      fsUtil.writeFile(this.experiencesUidMapperPath, this.experiencesUidMapper);
+      log.success('Experiences created successfully', this.config.context);
+
+      log.info('Validating variant and variant group creation', this.config.context);
+      this.pendingVariantAndVariantGrpForExperience = values(cloneDeep(this.experiencesUidMapper));
+      const jobRes = await this.validateVariantGroupAndVariantsCreated();
+      fsUtil.writeFile(this.cmsVariantPath, this.cmsVariants);
+      fsUtil.writeFile(this.cmsVariantGroupPath, this.cmsVariantGroups);
+
+      if (jobRes) {
+        log.success('Variant and variant groups created successfully', this.config.context);
+      } else {
+        log.error('Failed to create variants and variant groups', this.config.context);
+        this.personalizeConfig.importData = false;
       }
-    } else {
-      log.warn(`Experiences file not found: ${this.experiencesPath}`, this.config.context);
+
+      if (this.personalizeConfig.importData) {
+        log.info('Attaching content types to experiences', this.config.context);
+        await this.attachCTsInExperience();
+        log.success('Content types attached to experiences successfully', this.config.context);
+      }
+
+      await this.createVariantIdMapper();
+
+      // Only complete progress if we own the progress manager (no parent)
+      if (!this.parentProgressManager) {
+        this.completeProgress(true);
+      }
+
+      log.success(
+        `Experiences imported successfully! Total experiences: ${experiencesCount} - personalization enabled`,
+        this.config.context,
+      );
+    } catch (error) {
+      if (!this.parentProgressManager) {
+        this.completeProgress(false, (error as any)?.message || 'Experiences import failed');
+      }
+      handleAndLogError(error, this.config.context);
+      throw error;
     }
   }
 
+  private async analyzeExperiences(): Promise<[boolean, number]> {
+    return this.withLoadingSpinner('EXPERIENCES: Analyzing import data...', async () => {
+      log.debug(`Checking for experiences file: ${this.experiencesPath}`, this.config.context);
+
+      if (!existsSync(this.experiencesPath)) {
+        log.warn(`Experiences file not found: ${this.experiencesPath}`, this.config.context);
+        return [false, 0];
+      }
+
+      this.experiences = fsUtil.readFile(this.experiencesPath, true) as ExperienceStruct[];
+      const experiencesCount = this.experiences?.length || 0;
+
+      if (experiencesCount < 1) {
+        log.warn('No experiences found in file', this.config.context);
+        return [false, 0];
+      }
+
+      log.debug(`Found ${experiencesCount} experiences to import`, this.config.context);
+      return [true, experiencesCount];
+    });
+  }
+
   /**
    * function import experience versions from a JSON file and creates them in the project.
    */
   async importExperienceVersions(experience: ExperienceStruct, oldExperienceUid: string) {
     log.debug(`Importing versions for experience: ${oldExperienceUid}`, this.config.context);
-    
+
     const versionsPath = resolve(
       sanitizePath(this.experiencesDirPath),
       'versions',
@@ -191,7 +260,7 @@ export default class Experiences extends PersonalizationAdapter<ImportConfig> {
 
     const versions = fsUtil.readFile(versionsPath, true) as ExperienceStruct[];
     log.debug(`Found ${versions.length} versions for experience: ${oldExperienceUid}`, this.config.context);
-    
+
     const versionMap: Record<string, CreateExperienceVersionInput | undefined> = {
       ACTIVE: undefined,
       DRAFT: undefined,
@@ -258,8 +327,11 @@ export default class Experiences extends PersonalizationAdapter<ImportConfig> {
    * @returns
    */
   async validateVariantGroupAndVariantsCreated(retryCount = 0): Promise<any> {
-    log.debug(`Validating variant groups and variants creation - attempt ${retryCount + 1}/${this.maxValidateRetry}`, this.config.context);
-    
+    log.debug(
+      `Validating variant groups and variants creation - attempt ${retryCount + 1}/${this.maxValidateRetry}`,
+      this.config.context,
+    );
+
     try {
       const promises = this.pendingVariantAndVariantGrpForExperience.map(async (expUid) => {
         log.debug(`Checking experience: ${expUid}`, this.config.context);
@@ -289,7 +361,10 @@ export default class Experiences extends PersonalizationAdapter<ImportConfig> {
           return this.validateVariantGroupAndVariantsCreated(retryCount);
         } else {
           log.error('Personalize job failed to create variants and variant groups', this.config.context);
-          log.error(`Failed experiences: ${this.pendingVariantAndVariantGrpForExperience.join(', ')}`, this.config.context);
+          log.error(
+            `Failed experiences: ${this.pendingVariantAndVariantGrpForExperience.join(', ')}`,
+            this.config.context,
+          );
           fsUtil.writeFile(this.failedCmsExpPath, this.pendingVariantAndVariantGrpForExperience);
           return false;
         }
@@ -305,7 +380,7 @@ export default class Experiences extends PersonalizationAdapter<ImportConfig> {
 
   async attachCTsInExperience() {
     log.debug('Attaching content types to experiences', this.config.context);
-    
+
     try {
       // Read the created content types from the file
       this.createdCTs = fsUtil.readFile(this.cTsSuccessPath, true) as any;
@@ -313,22 +388,25 @@ export default class Experiences extends PersonalizationAdapter<ImportConfig> {
         log.debug('No Content types created, skipping following process', this.config.context);
         return;
       }
-      
+
       log.debug(`Found ${this.createdCTs.length} created content types`, this.config.context);
       const experienceCTsMap = fsUtil.readFile(this.experienceCTsPath, true) as Record<string, string[]>;
-      
+
       return await Promise.allSettled(
         Object.entries(this.experiencesUidMapper).map(async ([oldExpUid, newExpUid]) => {
           if (experienceCTsMap[oldExpUid]?.length) {
             log.debug(`Processing content types for experience: ${oldExpUid} -> ${newExpUid}`, this.config.context);
-            
+
             // Filter content types that were created
             const updatedContentTypes = experienceCTsMap[oldExpUid].filter(
               (ct: any) => this.createdCTs.includes(ct?.uid) && ct.status === 'linked',
             );
-            
+
             if (updatedContentTypes?.length) {
-              log.debug(`Attaching ${updatedContentTypes.length} content types to experience: ${newExpUid}`, this.config.context);
+              log.debug(
+                `Attaching ${updatedContentTypes.length} content types to experience: ${newExpUid}`,
+                this.config.context,
+              );
               const { variant_groups: [variantGroup] = [] } =
                 (await this.getVariantGroup({ experienceUid: newExpUid })) || {};
               variantGroup.content_types = updatedContentTypes;
@@ -349,11 +427,11 @@ export default class Experiences extends PersonalizationAdapter<ImportConfig> {
 
   async createVariantIdMapper() {
     log.debug('Creating variant ID mapper', this.config.context);
-    
+
     try {
       const experienceVariantIds: any = fsUtil.readFile(this.experienceVariantsIdsPath, true) || [];
       log.debug(`Found ${experienceVariantIds.length} experience variant IDs to process`, this.config.context);
-      
+
       const variantUIDMapper: Record<string, string> = {};
       for (let experienceVariantId of experienceVariantIds) {
         const [experienceId, variantShortId, oldVariantId] = experienceVariantId.split('-');

package/src/import/project.ts

@@ -1,12 +1,14 @@
 import { join, resolve as pResolve } from 'path';
 import { existsSync, readFileSync } from 'fs';
-import { sanitizePath, log } from '@contentstack/cli-utilities';
+import { sanitizePath, log, cliux } from '@contentstack/cli-utilities';
 import { PersonalizationAdapter, askProjectName, fsUtil } from '../utils';
 import { APIConfig, CreateProjectInput, ImportConfig, ProjectStruct } from '../types';
+import { PROCESS_NAMES, MODULE_CONTEXTS, IMPORT_PROCESS_STATUS } from '../utils/constants';
 
 export default class Project extends PersonalizationAdapter<ImportConfig> {
   private projectMapperFolderPath: string;
-  
+  private projectsData: CreateProjectInput[];
+
   constructor(public readonly config: ImportConfig) {
     const conf: APIConfig = {
       config,
@@ -14,50 +16,56 @@ export default class Project extends PersonalizationAdapter<ImportConfig> {
       headers: { organization_uid: config.org_uid },
     };
     super(Object.assign(config, conf));
-    
+
     this.projectMapperFolderPath = pResolve(
       sanitizePath(this.config.backupDir),
       'mapper',
       sanitizePath(this.config.modules.personalize.dirName),
       'projects',
     );
-    this.config.context.module = 'project';
+    this.config.context.module = MODULE_CONTEXTS.PROJECTS;
+    this.projectsData = [];
   }
 
   /**
    * The function asynchronously imports projects data from a file and creates projects based on the
    * data.
    */
-  async import() {    
-    const personalize = this.config.modules.personalize;
-    const { dirName, fileName } = personalize.projects;
-    const projectPath = join(
-      sanitizePath(this.config.data),
-      sanitizePath(personalize.dirName),
-      sanitizePath(dirName),
-      sanitizePath(fileName),
-    );
-
-    log.debug(`Checking for project file: ${projectPath}`, this.config.context);
-    
-    if (existsSync(projectPath)) {
-      const projects = JSON.parse(readFileSync(projectPath, 'utf8')) as CreateProjectInput[];
-      log.debug(`Loaded ${projects?.length || 0} projects from file`, this.config.context);
+  async import() {
+    try {
+      log.debug('Starting personalize project import...', this.config.context);
 
-      if (!projects || projects.length < 1) {
-        this.config.modules.personalize.importData = false; // Stop personalize import if stack not connected to any project
-        log.warn('No projects found in file', this.config.context);
+      const [canImport, projectsCount] = await this.analyzeProjects();
+      if (!canImport) {
+        log.info('No projects found to import', this.config.context);
+        if (this.parentProgressManager) {
+          this.parentProgressManager.tick(true, 'projects module (no data)', null, PROCESS_NAMES.PROJECTS);
+        }
         return;
       }
-      
+
+      // Fix 1: Always use parent progress manager when available
+      let progress;
+      if (this.parentProgressManager) {
+        progress = this.parentProgressManager;
+        log.debug('Using parent progress manager for projects import', this.config.context);
+        // Don't create our own progress - use parent's
+      } else {
+        progress = this.createSimpleProgress(PROCESS_NAMES.PROJECTS, projectsCount);
+        log.debug('Created standalone progress manager for projects import', this.config.context);
+      }
+
       await this.init();
-      
-      for (const project of projects) {
+
+      for (const project of this.projectsData) {
+        if (!this.parentProgressManager) {
+          progress.updateStatus(IMPORT_PROCESS_STATUS[PROCESS_NAMES.PROJECTS].CREATING);
+        }
         log.debug(`Processing project: ${project.name}`, this.config.context);
-        
+
         const createProject = async (newName: void | string): Promise<ProjectStruct> => {
           log.debug(`Creating project with name: ${newName || project.name}`, this.config.context);
-          
+
           return await this.createProject({
             name: newName || project.name,
             description: project.description,
@@ -68,26 +76,88 @@ export default class Project extends PersonalizationAdapter<ImportConfig> {
               error.includes('personalize.PROJECTS.DUPLICATE_NAME')
             ) {
               log.warn(`Project name already exists, generating new name`, this.config.context);
+
+              // Prevent progress bar corruption with clean newlines
+              cliux.print('\n');
               const projectName = await askProjectName('Copy Of ' + (newName || project.name));
+              cliux.print('\n');
+              if (this.parentProgressManager) {
+                this.parentProgressManager.updateStatus(
+                  IMPORT_PROCESS_STATUS[PROCESS_NAMES.PROJECTS].CREATING,
+                  PROCESS_NAMES.PROJECTS,
+                );
+              }
+
               return await createProject(projectName);
             }
             throw error;
           });
         };
 
-        const projectRes = await createProject(this.config.personalizeProjectName);
-        this.config.modules.personalize.project_id = projectRes.uid;
-        this.config.modules.personalize.importData = true;
+        try {
+          const projectRes = await createProject(this.config.personalizeProjectName);
+          this.config.modules.personalize.project_id = projectRes.uid;
+          this.config.modules.personalize.importData = true;
+
+          await fsUtil.makeDirectory(this.projectMapperFolderPath);
+          fsUtil.writeFile(pResolve(sanitizePath(this.projectMapperFolderPath), 'projects.json'), projectRes);
 
-        await fsUtil.makeDirectory(this.projectMapperFolderPath);
-        fsUtil.writeFile(pResolve(sanitizePath(this.projectMapperFolderPath), 'projects.json'), projectRes);
-        
-        log.success(`Project created successfully: ${projectRes.uid}`, this.config.context);
-        log.debug(`Project data saved to: ${this.projectMapperFolderPath}/projects.json`, this.config.context);
+          this.updateProgress(true, `project: ${project.name}`, undefined, PROCESS_NAMES.PROJECTS);
+          log.success(`Project created successfully: ${projectRes.uid}`, this.config.context);
+        } catch (error) {
+          this.updateProgress(false, `project: ${project.name}`, (error as any)?.message, PROCESS_NAMES.PROJECTS);
+          throw error;
+        }
       }
-    } else {
-      this.config.modules.personalize.importData = false; // Stop personalize import if stack not connected to any project
-      log.warn(`Project file not found: ${projectPath}`, this.config.context);
+
+      // Only complete progress if we own the progress manager (no parent)
+      if (!this.parentProgressManager) {
+        this.completeProgress(true);
+      }
+
+      log.success(
+        `Projects imported successfully! Total projects: ${projectsCount} - personalization enabled`,
+        this.config.context,
+      );
+    } catch (error) {
+      this.config.modules.personalize.importData = false;
+      if (!this.parentProgressManager) {
+        this.completeProgress(false, (error as any)?.message || 'Project import failed');
+      }
+      throw error;
     }
   }
+
+  private async analyzeProjects(): Promise<[boolean, number]> {
+    return this.withLoadingSpinner('PROJECT: Analyzing import data...', async () => {
+      const personalize = this.config.modules.personalize;
+      const { dirName, fileName } = personalize.projects;
+      const projectPath = join(
+        sanitizePath(this.config.data),
+        sanitizePath(personalize.dirName),
+        sanitizePath(dirName),
+        sanitizePath(fileName),
+      );
+
+      log.debug(`Checking for project file: ${projectPath}`, this.config.context);
+
+      if (!existsSync(projectPath)) {
+        this.config.modules.personalize.importData = false;
+        log.warn(`Project file not found: ${projectPath}`, this.config.context);
+        return [false, 0];
+      }
+
+      this.projectsData = JSON.parse(readFileSync(projectPath, 'utf8')) as CreateProjectInput[];
+      const projectsCount = this.projectsData?.length || 0;
+
+      if (projectsCount < 1) {
+        this.config.modules.personalize.importData = false;
+        log.warn('No projects found in file', this.config.context);
+        return [false, 0];
+      }
+
+      log.debug(`Found ${projectsCount} projects to import`, this.config.context);
+      return [true, projectsCount];
+    });
+  }
 }