@contentstack/cli-variants 1.3.3 → 2.0.0-beta

package/src/import/audiences.ts

@@ -3,6 +3,7 @@ import { existsSync } from 'fs';
 import { sanitizePath, log, handleAndLogError } from '@contentstack/cli-utilities';
 import { APIConfig, AudienceStruct, ImportConfig } from '../types';
 import { PersonalizationAdapter, fsUtil, lookUpAttributes } from '../utils';
+import { PROCESS_NAMES, MODULE_CONTEXTS, IMPORT_PROCESS_STATUS } from '../utils/constants';
 
 export default class Audiences extends PersonalizationAdapter<ImportConfig> {
   private mapperDirPath: string;
@@ -13,15 +14,16 @@ export default class Audiences extends PersonalizationAdapter<ImportConfig> {
   private personalizeConfig: ImportConfig['modules']['personalize'];
   private audienceConfig: ImportConfig['modules']['personalize']['audiences'];
   public attributeConfig: ImportConfig['modules']['personalize']['attributes'];
+  private audiences: AudienceStruct[];
 
-  constructor(public readonly config: ImportConfig ) {  
+  constructor(public readonly config: ImportConfig) {
     const conf: APIConfig = {
       config,
       baseURL: config.modules.personalize.baseURL[config.region.name],
       headers: { 'X-Project-Uid': config.modules.personalize.project_id },
     };
     super(Object.assign(config, conf));
-    
+
     this.personalizeConfig = this.config.modules.personalize;
     this.audienceConfig = this.personalizeConfig.audiences;
     this.attributeConfig = this.personalizeConfig.attributes;
@@ -38,68 +40,122 @@ export default class Audiences extends PersonalizationAdapter<ImportConfig> {
       'uid-mapping.json',
     );
     this.audiencesUidMapper = {};
-    this.config.context.module = 'audiences';
+    this.config.context.module = MODULE_CONTEXTS.AUDIENCES;
+    this.audiences = [];
   }
 
   /**
    * The function asynchronously imports audiences from a JSON file and creates them in the system.
    */
-  async import() {   
-    await this.init();
-    await fsUtil.makeDirectory(this.audienceMapperDirPath);
-    log.debug(`Created mapper directory: ${this.audienceMapperDirPath}`, this.config.context);
-    
-    const { dirName, fileName } = this.audienceConfig;
-    const audiencesPath = resolve(
-      sanitizePath(this.config.data),
-      sanitizePath(this.personalizeConfig.dirName),
-      sanitizePath(dirName),
-      sanitizePath(fileName),
-    );
+  async import() {
+    try {
+      log.debug('Starting audiences import...', this.config.context);
 
-    log.debug(`Checking for audiences file: ${audiencesPath}`, this.config.context);
-    
-    if (existsSync(audiencesPath)) {
-      try {
-        const audiences = fsUtil.readFile(audiencesPath, true) as AudienceStruct[];
-        log.info(`Found ${audiences.length} audiences to import`, this.config.context);
-        
-        const attributesUid = (fsUtil.readFile(this.attributesMapperPath, true) as Record<string, string>) || {};
-        log.debug(`Loaded ${Object.keys(attributesUid).length} attribute mappings for audience processing`, this.config.context);
-
-        for (const audience of audiences) {
-          let { name, definition, description, uid } = audience;
-          log.debug(`Processing audience: ${name} (${uid})`, this.config.context);
-          
-          try {
-            //check whether reference attributes exists or not
-            if (definition.rules?.length) {
-              log.debug(`Processing ${definition.rules.length} definition rules for audience: ${name}`, this.config.context);
-              definition.rules = lookUpAttributes(definition.rules, attributesUid);
-              log.debug(`Processed definition rules, remaining rules: ${definition.rules.length}`, this.config.context);
-            } else {
-              log.debug(`No definition rules found for audience: ${name}`, this.config.context);
-            }
-            
-            log.debug(`Creating audience: ${name}`, this.config.context);
-            const audienceRes = await this.createAudience({ definition, name, description });
-            //map old audience uid to new audience uid
-            //mapper file is used to check whether audience created or not before creating experience
-            this.audiencesUidMapper[uid] = audienceRes?.uid ?? '';
-            log.debug(`Created audience: ${uid} -> ${audienceRes?.uid}`, this.config.context);
-          } catch (error) {
-            handleAndLogError(error, this.config.context, `Failed to create audience: ${name} (${uid})`);
+      const [canImport, audiencesCount] = await this.analyzeAudiences();
+      if (!canImport) {
+        log.info('No audiences found to import', this.config.context);
+        // Still need to mark as complete for parent progress
+        if (this.parentProgressManager) {
+          this.parentProgressManager.tick(true, 'audiences module (no data)', null, PROCESS_NAMES.AUDIENCES);
+        }
+        return;
+      }
+
+      // Don't create own progress manager if we have a parent
+      let progress;
+      if (this.parentProgressManager) {
+        progress = this.parentProgressManager;
+        log.debug('Using parent progress manager for audiences import', this.config.context);
+        this.parentProgressManager.updateProcessTotal(PROCESS_NAMES.AUDIENCES, audiencesCount);
+      } else {
+        progress = this.createSimpleProgress(PROCESS_NAMES.AUDIENCES, audiencesCount);
+        log.debug('Created standalone progress manager for audiences import', this.config.context);
+      }
+
+      await this.init();
+      await fsUtil.makeDirectory(this.audienceMapperDirPath);
+      log.debug(`Created mapper directory: ${this.audienceMapperDirPath}`, this.config.context);
+
+      const attributesUid = (fsUtil.readFile(this.attributesMapperPath, true) as Record<string, string>) || {};
+      log.debug(
+        `Loaded ${Object.keys(attributesUid).length} attribute mappings for audience processing`,
+        this.config.context,
+      );
+
+      for (const audience of this.audiences) {
+        let { name, definition, description, uid } = audience;
+        if (!this.parentProgressManager) {
+          progress.updateStatus(IMPORT_PROCESS_STATUS[PROCESS_NAMES.AUDIENCES].CREATING);
+        }
+        log.debug(`Processing audience: ${name} (${uid})`, this.config.context);
+
+        try {
+          //check whether reference attributes exists or not
+          if (definition.rules?.length) {
+            log.debug(
+              `Processing ${definition.rules.length} definition rules for audience: ${name}`,
+              this.config.context,
+            );
+            definition.rules = lookUpAttributes(definition.rules, attributesUid);
+            log.debug(`Processed definition rules, remaining rules: ${definition.rules.length}`, this.config.context);
+          } else {
+            log.debug(`No definition rules found for audience: ${name}`, this.config.context);
           }
+
+          log.debug(`Creating audience: ${name}`, this.config.context);
+          const audienceRes = await this.createAudience({ definition, name, description });
+          //map old audience uid to new audience uid
+          //mapper file is used to check whether audience created or not before creating experience
+          this.audiencesUidMapper[uid] = audienceRes?.uid ?? '';
+
+          this.updateProgress(true, `audience: ${name}`, undefined, PROCESS_NAMES.AUDIENCES);
+          log.debug(`Created audience: ${uid} -> ${audienceRes?.uid}`, this.config.context);
+        } catch (error) {
+          this.updateProgress(false, `audience: ${name}`, (error as any)?.message, PROCESS_NAMES.AUDIENCES);
+          handleAndLogError(error, this.config.context, `Failed to create audience: ${name} (${uid})`);
         }
+      }
+
+      fsUtil.writeFile(this.audiencesUidMapperPath, this.audiencesUidMapper);
+      log.debug(`Saved ${Object.keys(this.audiencesUidMapper).length} audience mappings`, this.config.context);
 
-        fsUtil.writeFile(this.audiencesUidMapperPath, this.audiencesUidMapper);
-        log.debug(`Saved ${Object.keys(this.audiencesUidMapper).length} audience mappings to: ${this.audiencesUidMapperPath}`, this.config.context);
-        log.success('Audiences imported successfully', this.config.context);
-      } catch (error) {
-        handleAndLogError(error, this.config.context);
+      // Only complete progress if we own the progress manager (no parent)
+      if (!this.parentProgressManager) {
+        this.completeProgress(true);
       }
-    } else {
-      log.warn(`Audiences file not found: ${audiencesPath}`, this.config.context);
+
+      log.success(`Audiences imported successfully! Total audiences: ${audiencesCount}`, this.config.context);
+    } catch (error) {
+      if (!this.parentProgressManager) {
+        this.completeProgress(false, (error as any)?.message || 'Audiences import failed');
+      }
+      handleAndLogError(error, this.config.context);
+      throw error;
     }
   }
+
+  private async analyzeAudiences(): Promise<[boolean, number]> {
+    return this.withLoadingSpinner('AUDIENCES: Analyzing import data...', async () => {
+      const { dirName, fileName } = this.audienceConfig;
+      const audiencesPath = resolve(
+        sanitizePath(this.config.data),
+        sanitizePath(this.personalizeConfig.dirName),
+        sanitizePath(dirName),
+        sanitizePath(fileName),
+      );
+
+      log.debug(`Checking for audiences file: ${audiencesPath}`, this.config.context);
+
+      if (!existsSync(audiencesPath)) {
+        log.warn(`Audiences file not found: ${audiencesPath}`, this.config.context);
+        return [false, 0];
+      }
+
+      this.audiences = fsUtil.readFile(audiencesPath, true) as AudienceStruct[];
+      const audiencesCount = this.audiences?.length || 0;
+
+      log.debug(`Found ${audiencesCount} audiences to import`, this.config.context);
+      return [audiencesCount > 0, audiencesCount];
+    });
+  }
 }

package/src/import/events.ts

@@ -3,6 +3,7 @@ import { existsSync } from 'fs';
 import { sanitizePath, log, handleAndLogError } from '@contentstack/cli-utilities';
 import { PersonalizationAdapter, fsUtil } from '../utils';
 import { APIConfig, EventStruct, ImportConfig } from '../types';
+import { PROCESS_NAMES, MODULE_CONTEXTS, IMPORT_PROCESS_STATUS } from '../utils/constants';
 
 export default class Events extends PersonalizationAdapter<ImportConfig> {
   private mapperDirPath: string;
@@ -10,7 +11,8 @@ export default class Events extends PersonalizationAdapter<ImportConfig> {
   private eventsUidMapperPath: string;
   private eventsUidMapper: Record<string, unknown>;
   private personalizeConfig: ImportConfig['modules']['personalize'];
-  private eventsConfig: ImportConfig['modules']['personalize']['events'];
+  private eventConfig: ImportConfig['modules']['personalize']['events'];
+  private events: EventStruct[];
 
   constructor(public readonly config: ImportConfig) {
     const conf: APIConfig = {
@@ -19,65 +21,126 @@ export default class Events extends PersonalizationAdapter<ImportConfig> {
       headers: { 'X-Project-Uid': config.modules.personalize.project_id },
     };
     super(Object.assign(config, conf));
-    
+
     this.personalizeConfig = this.config.modules.personalize;
-    this.eventsConfig = this.personalizeConfig.events;
+    this.eventConfig = this.personalizeConfig.events;
     this.mapperDirPath = resolve(
       sanitizePath(this.config.backupDir),
       'mapper',
       sanitizePath(this.personalizeConfig.dirName),
     );
-    this.eventMapperDirPath = resolve(sanitizePath(this.mapperDirPath), sanitizePath(this.eventsConfig.dirName));
+    this.eventMapperDirPath = resolve(sanitizePath(this.mapperDirPath), sanitizePath(this.eventConfig.dirName));
     this.eventsUidMapperPath = resolve(sanitizePath(this.eventMapperDirPath), 'uid-mapping.json');
     this.eventsUidMapper = {};
-    this.config.context.module = 'events';
+    this.events = [];
+    this.config.context.module = MODULE_CONTEXTS.EVENTS;
   }
 
   /**
    * The function asynchronously imports events from a JSON file and creates them in the system.
    */
   async import() {
-    await this.init();
-    await fsUtil.makeDirectory(this.eventMapperDirPath);
-    log.debug(`Created mapper directory: ${this.eventMapperDirPath}`, this.config.context);
-    
-    const { dirName, fileName } = this.eventsConfig;
-    const eventsPath = resolve(
-      sanitizePath(this.config.data),
-      sanitizePath(this.personalizeConfig.dirName),
-      sanitizePath(dirName),
-      sanitizePath(fileName),
-    );
+    try {
+      log.debug('Starting events import...', this.config.context);
+
+      const [canImport, eventsCount] = await this.analyzeEvents();
+      if (!canImport) {
+        log.info('No events found to import', this.config.context);
+        // Still need to mark as complete for parent progress
+        if (this.parentProgressManager) {
+          this.parentProgressManager.tick(true, 'events module (no data)', null, PROCESS_NAMES.EVENTS);
+        }
+        return;
+      }
+
+      // Don't create own progress manager if we have a parent
+      let progress;
+      if (this.parentProgressManager) {
+        progress = this.parentProgressManager;
+        log.debug('Using parent progress manager for events import', this.config.context);
+        this.parentProgressManager.updateProcessTotal(PROCESS_NAMES.EVENTS, eventsCount);
+      } else {
+        progress = this.createSimpleProgress(PROCESS_NAMES.EVENTS, eventsCount);
+        log.debug('Created standalone progress manager for events import', this.config.context);
+      }
+
+      await this.init();
+      await fsUtil.makeDirectory(this.eventMapperDirPath);
+      log.debug(`Created mapper directory: ${this.eventMapperDirPath}`, this.config.context);
+
+      log.info(`Processing ${eventsCount} events`, this.config.context);
+
+      for (const event of this.events) {
+        const { key, description, uid } = event;
+        if (!this.parentProgressManager) {
+          progress.updateStatus(IMPORT_PROCESS_STATUS[PROCESS_NAMES.EVENTS].CREATING);
+        }
+        log.debug(`Processing event: ${key} (${uid})`, this.config.context);
 
-    log.debug(`Checking for events file: ${eventsPath}`, this.config.context);
-    
-    if (existsSync(eventsPath)) {
-      try {
-        const events = fsUtil.readFile(eventsPath, true) as EventStruct[];
-        log.info(`Found ${events.length} events to import`, this.config.context);
-
-        for (const event of events) {
-          const { key, description, uid } = event;
-          log.debug(`Processing event: ${key} (${uid})`, this.config.context);
-          
-          try {
-            log.debug(`Creating event: ${key}`, this.config.context);
-            const eventsResponse = await this.createEvents({ key, description });
-            this.eventsUidMapper[uid] = eventsResponse?.uid ?? '';
-            log.debug(`Created event: ${uid} -> ${eventsResponse?.uid}`, this.config.context);
-          } catch (error) {
-            handleAndLogError(error, this.config.context, `Failed to create event: ${key} (${uid})`);
+        try {
+          log.debug(`Creating event: ${key}`, this.config.context);
+          const eventRes = await this.createEvents({ key, description });
+          this.eventsUidMapper[uid] = eventRes?.uid ?? '';
+
+          // For parent progress manager, we don't need to specify process name as it will be handled automatically
+          if (this.parentProgressManager) {
+            this.updateProgress(true, `event: ${key}`);
+          } else {
+            this.updateProgress(true, `event: ${key}`, undefined, PROCESS_NAMES.EVENTS);
+          }
+          log.debug(`Created event: ${uid} -> ${eventRes?.uid}`, this.config.context);
+        } catch (error) {
+          if (this.parentProgressManager) {
+            this.updateProgress(false, `event: ${key}`, (error as any)?.message);
+          } else {
+            this.updateProgress(false, `event: ${key}`, (error as any)?.message, PROCESS_NAMES.EVENTS);
           }
+          handleAndLogError(error, this.config.context, `Failed to create event: ${key} (${uid})`);
         }
+      }
 
-        fsUtil.writeFile(this.eventsUidMapperPath, this.eventsUidMapper);
-        log.debug(`Saved ${Object.keys(this.eventsUidMapper).length} event mappings to: ${this.eventsUidMapperPath}`, this.config.context);
-        log.success('Events imported successfully', this.config.context);
-      } catch (error) {
-        handleAndLogError(error, this.config.context);
+      fsUtil.writeFile(this.eventsUidMapperPath, this.eventsUidMapper);
+      log.debug(`Saved ${Object.keys(this.eventsUidMapper).length} event mappings`, this.config.context);
+
+      // Only complete progress if we own the progress manager (no parent)
+      if (!this.parentProgressManager) {
+        this.completeProgress(true);
+      }
+      log.success(
+        `Events imported successfully! Total events: ${eventsCount} - personalization enabled`,
+        this.config.context,
+      );
+    } catch (error) {
+      if (!this.parentProgressManager) {
+        this.completeProgress(false, (error as any)?.message || 'Events import failed');
       }
-    } else {
-      log.warn(`Events file not found: ${eventsPath}`, this.config.context);
+      handleAndLogError(error, this.config.context);
+      throw error;
     }
   }
+
+  private async analyzeEvents(): Promise<[boolean, number]> {
+    return this.withLoadingSpinner('EVENTS: Analyzing import data...', async () => {
+      const { dirName, fileName } = this.eventConfig;
+      const eventsPath = resolve(
+        sanitizePath(this.config.data),
+        sanitizePath(this.personalizeConfig.dirName),
+        sanitizePath(dirName),
+        sanitizePath(fileName),
+      );
+
+      log.debug(`Checking for events file: ${eventsPath}`, this.config.context);
+
+      if (!existsSync(eventsPath)) {
+        log.warn(`Events file not found: ${eventsPath}`, this.config.context);
+        return [false, 0];
+      }
+
+      this.events = fsUtil.readFile(eventsPath, true) as EventStruct[];
+      const eventsCount = this.events?.length || 0;
+
+      log.debug(`Found ${eventsCount} events to import`, this.config.context);
+      return [eventsCount > 0, eventsCount];
+    });
+  }
 }