@contentstack/cli-variants 1.2.1 → 1.3.0

package/src/import/attribute.ts

@@ -1,6 +1,6 @@
 import { resolve } from 'path';
 import { existsSync } from 'fs';
-import { sanitizePath } from '@contentstack/cli-utilities';
+import { sanitizePath, log, handleAndLogError } from '@contentstack/cli-utilities';
 import { PersonalizationAdapter, fsUtil } from '../utils';
 import { APIConfig, AttributeStruct, ImportConfig, LogType } from '../types';
 
@@ -12,13 +12,14 @@ export default class Attribute extends PersonalizationAdapter<ImportConfig> {
   private personalizeConfig: ImportConfig['modules']['personalize'];
   private attributeConfig: ImportConfig['modules']['personalize']['attributes'];
 
-  constructor(public readonly config: ImportConfig, private readonly log: LogType = console.log) {
+  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.attributeConfig = this.personalizeConfig.attributes;
     this.mapperDirPath = resolve(
@@ -29,15 +30,17 @@ export default class Attribute extends PersonalizationAdapter<ImportConfig> {
     this.attrMapperDirPath = resolve(sanitizePath(this.mapperDirPath), sanitizePath(this.attributeConfig.dirName));
     this.attributesUidMapperPath = resolve(sanitizePath(this.attrMapperDirPath), 'uid-mapping.json');
     this.attributesUidMapper = {};
+    this.config.context.module = 'attributes';
   }
 
   /**
    * The function asynchronously imports attributes from a JSON file and creates them in the system.
    */
-  async import() {
-    this.log(this.config, this.$t(this.messages.IMPORT_MSG, { module: 'Attributes' }), 'info');
+  async import() {  
     await this.init();
     await fsUtil.makeDirectory(this.attrMapperDirPath);
+    log.debug(`Created mapper directory: ${this.attrMapperDirPath}`, this.config.context);
+    
     const { dirName, fileName } = this.attributeConfig;
     const attributesPath = resolve(
       sanitizePath(this.config.data),
@@ -46,33 +49,43 @@ export default class Attribute extends PersonalizationAdapter<ImportConfig> {
       sanitizePath(fileName),
     );
 
+    log.debug(`Checking for attributes file: ${attributesPath}`, this.config.context);
+    
     if (existsSync(attributesPath)) {
       try {
         const attributes = fsUtil.readFile(attributesPath, true) as AttributeStruct[];
+        log.info(`Found ${attributes.length} attributes to import`, this.config.context);
 
         for (const attribute of attributes) {
           const { key, name, description, uid } = attribute;
+          log.debug(`Processing attribute: ${name} - ${attribute.__type}`, this.config.context);
+          
           // skip creating preset attributes, as they are already present in the system
           if (attribute.__type === 'PRESET') {
+            log.debug(`Skipping preset attribute: ${name}`, this.config.context);
             continue;
           }
+          
           try {
+            log.debug(`Creating custom attribute: ${name}`, this.config.context);
             const attributeRes = await this.createAttribute({ key, name, description });
             //map old attribute uid to new attribute uid
             //mapper file is used to check whether attribute created or not before creating audience
             this.attributesUidMapper[uid] = attributeRes?.uid ?? '';
+            log.debug(`Created attribute: ${uid} -> ${attributeRes?.uid}`, this.config.context);
           } catch (error) {
-            this.log(this.config, `Failed to create attribute ${name}!`, 'error');
-            this.log(this.config, error, 'error');
+            handleAndLogError(error, this.config.context, `Failed to create attribute: ${name}`);
           }
         }
 
         fsUtil.writeFile(this.attributesUidMapperPath, this.attributesUidMapper);
-        this.log(this.config, this.$t(this.messages.CREATE_SUCCESS, { module: 'Attributes' }), 'info');
+        log.debug(`Saved ${Object.keys(this.attributesUidMapper).length} attribute mappings to: ${this.attributesUidMapperPath}`, this.config.context);
+        log.success('Attributes imported successfully', this.config.context);
       } catch (error) {
-        this.log(this.config, this.$t(this.messages.CREATE_FAILURE, { module: 'Attributes' }), 'error');
-        this.log(this.config, error, 'error');
+        handleAndLogError(error, this.config.context);
       }
+    } else {
+      log.warn(`Attributes file not found: ${attributesPath}`, this.config.context);
     }
   }
 }

package/src/import/audiences.ts

@@ -1,7 +1,7 @@
 import { resolve } from 'path';
 import { existsSync } from 'fs';
-import { sanitizePath } from '@contentstack/cli-utilities';
-import { APIConfig, AudienceStruct, ImportConfig, LogType } from '../types';
+import { sanitizePath, log, handleAndLogError } from '@contentstack/cli-utilities';
+import { APIConfig, AudienceStruct, ImportConfig } from '../types';
 import { PersonalizationAdapter, fsUtil, lookUpAttributes } from '../utils';
 
 export default class Audiences extends PersonalizationAdapter<ImportConfig> {
@@ -14,13 +14,14 @@ export default class Audiences extends PersonalizationAdapter<ImportConfig> {
   private audienceConfig: ImportConfig['modules']['personalize']['audiences'];
   public attributeConfig: ImportConfig['modules']['personalize']['attributes'];
 
-  constructor(public readonly config: ImportConfig, private readonly log: LogType = console.log) {
+  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;
@@ -37,15 +38,17 @@ export default class Audiences extends PersonalizationAdapter<ImportConfig> {
       'uid-mapping.json',
     );
     this.audiencesUidMapper = {};
+    this.config.context.module = 'audiences';
   }
 
   /**
    * The function asynchronously imports audiences from a JSON file and creates them in the system.
    */
-  async import() {
-    this.log(this.config, this.$t(this.messages.IMPORT_MSG, { module: 'Audiences' }), 'info');
+  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),
@@ -54,34 +57,49 @@ export default class Audiences extends PersonalizationAdapter<ImportConfig> {
       sanitizePath(fileName),
     );
 
+    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) {
-            this.log(this.config, `Failed to create audience uid: ${uid}, name: ${name}`, 'error');
-            this.log(this.config, error, 'error');
+            handleAndLogError(error, this.config.context, `Failed to create audience: ${name} (${uid})`);
           }
         }
 
         fsUtil.writeFile(this.audiencesUidMapperPath, this.audiencesUidMapper);
-        this.log(this.config, this.$t(this.messages.CREATE_SUCCESS, { module: 'Audiences' }), 'info');
+        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) {
-        this.log(this.config, this.$t(this.messages.CREATE_FAILURE, { module: 'Audiences' }), 'error');
-        this.log(this.config, error, 'error');
+        handleAndLogError(error, this.config.context);
       }
+    } else {
+      log.warn(`Audiences file not found: ${audiencesPath}`, this.config.context);
     }
   }
 }

package/src/import/events.ts

@@ -1,8 +1,8 @@
 import { resolve } from 'path';
 import { existsSync } from 'fs';
-import { sanitizePath } from '@contentstack/cli-utilities';
+import { sanitizePath, log, handleAndLogError } from '@contentstack/cli-utilities';
 import { PersonalizationAdapter, fsUtil } from '../utils';
-import { APIConfig, EventStruct, ImportConfig, LogType } from '../types';
+import { APIConfig, EventStruct, ImportConfig } from '../types';
 
 export default class Events extends PersonalizationAdapter<ImportConfig> {
   private mapperDirPath: string;
@@ -12,13 +12,14 @@ export default class Events extends PersonalizationAdapter<ImportConfig> {
   private personalizeConfig: ImportConfig['modules']['personalize'];
   private eventsConfig: ImportConfig['modules']['personalize']['events'];
 
-  constructor(public readonly config: ImportConfig, private readonly log: LogType = console.log) {
+  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.eventsConfig = this.personalizeConfig.events;
     this.mapperDirPath = resolve(
@@ -29,15 +30,17 @@ export default class Events extends PersonalizationAdapter<ImportConfig> {
     this.eventMapperDirPath = resolve(sanitizePath(this.mapperDirPath), sanitizePath(this.eventsConfig.dirName));
     this.eventsUidMapperPath = resolve(sanitizePath(this.eventMapperDirPath), 'uid-mapping.json');
     this.eventsUidMapper = {};
+    this.config.context.module = 'events';
   }
 
   /**
-   * The function asynchronously imports attributes from a JSON file and creates them in the system.
+   * The function asynchronously imports events from a JSON file and creates them in the system.
    */
   async import() {
-    this.log(this.config, this.$t(this.messages.IMPORT_MSG, { module: 'Events' }), 'info');
     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),
@@ -46,27 +49,35 @@ export default class Events extends PersonalizationAdapter<ImportConfig> {
       sanitizePath(fileName),
     );
 
+    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) {
-            this.log(this.config, `failed to create event uid: ${uid}`, 'error');
-            this.log(this.config, error, 'error');
+            handleAndLogError(error, this.config.context, `Failed to create event: ${key} (${uid})`);
           }
         }
 
         fsUtil.writeFile(this.eventsUidMapperPath, this.eventsUidMapper);
-        this.log(this.config, this.$t(this.messages.CREATE_SUCCESS, { module: 'Events' }), 'info');
+        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) {
-        this.log(this.config, this.$t(this.messages.CREATE_FAILURE, { module: 'Events' }), 'error');
-        this.log(this.config, error, 'error');
+        handleAndLogError(error, this.config.context);
       }
+    } else {
+      log.warn(`Events file not found: ${eventsPath}`, this.config.context);
     }
   }
 }

package/src/import/experiences.ts

@@ -2,16 +2,16 @@ import { join, resolve } from 'path';
 import { existsSync } from 'fs';
 import values from 'lodash/values';
 import cloneDeep from 'lodash/cloneDeep';
-import { sanitizePath } from '@contentstack/cli-utilities';
+import { sanitizePath, log, handleAndLogError } from '@contentstack/cli-utilities';
 import { PersonalizationAdapter, fsUtil, lookUpAudiences, lookUpEvents } from '../utils';
 import {
   APIConfig,
   ImportConfig,
   ExperienceStruct,
   CreateExperienceInput,
-  LogType,
   CreateExperienceVersionInput,
 } from '../types';
+
 export default class Experiences extends PersonalizationAdapter<ImportConfig> {
   private createdCTs: string[];
   private mapperDirPath: string;
@@ -41,8 +41,8 @@ export default class Experiences extends PersonalizationAdapter<ImportConfig> {
   private audienceConfig: ImportConfig['modules']['personalize']['audiences'];
   private experienceConfig: ImportConfig['modules']['personalize']['experiences'];
 
-  constructor(public readonly config: ImportConfig, private readonly log: LogType = console.log) {
-    const conf: APIConfig = {
+  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 },
@@ -52,6 +52,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),
@@ -100,22 +101,28 @@ 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';
   }
 
   /**
    * The function asynchronously imports experiences from a JSON file and creates them in the system.
    */
-  async import() {
-    this.log(this.config, this.$t(this.messages.IMPORT_MSG, { module: 'Experiences' }), 'info');
+  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
@@ -124,40 +131,44 @@ export default class Experiences extends PersonalizationAdapter<ImportConfig> {
           const expRes = (await this.createExperience(experienceReqObj)) as ExperienceStruct;
           //map old experience uid to new experience uid
           this.experiencesUidMapper[uid] = expRes?.uid ?? '';
+          log.debug(`Created experience: ${uid} -> ${expRes?.uid}`, this.config.context);
 
           try {
             // import versions of experience
             await this.importExperienceVersions(expRes, uid);
           } catch (error) {
-            this.log(this.config, `Error while importing experience versions of ${expRes.uid}`, 'error');
-            this.log(this.config, error, 'error');
+            handleAndLogError(error, this.config.context, `Failed to import experience versions for ${expRes.uid}`);
           }
         }
+        
         fsUtil.writeFile(this.experiencesUidMapperPath, this.experiencesUidMapper);
-        this.log(this.config, this.$t(this.messages.CREATE_SUCCESS, { module: 'Experiences' }), 'info');
+        log.success('Experiences created successfully', this.config.context);
 
-        this.log(this.config, this.messages.VALIDATE_VARIANT_AND_VARIANT_GRP, 'info');
+        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) {
-          this.log(this.config, this.$t(this.messages.CREATE_SUCCESS, { module: 'Variant & Variant groups' }), 'info');
+          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) {
-          this.log(this.config, this.messages.UPDATING_CT_IN_EXP, 'info');
+          log.info('Attaching content types to experiences', this.config.context);
           await this.attachCTsInExperience();
-          this.log(this.config, this.messages.UPDATED_CT_IN_EXP, 'info');
+          log.success('Content types attached to experiences successfully', this.config.context);
         }
 
         await this.createVariantIdMapper();
       } catch (error) {
-        this.log(this.config, this.$t(this.messages.CREATE_FAILURE, { module: 'Experiences' }), 'error');
-        this.log(this.config, error, 'error');
+        handleAndLogError(error, this.config.context);
       }
+    } else {
+      log.warn(`Experiences file not found: ${this.experiencesPath}`, this.config.context);
     }
   }
 
@@ -165,6 +176,8 @@ export default class Experiences extends PersonalizationAdapter<ImportConfig> {
    * 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',
@@ -172,10 +185,13 @@ export default class Experiences extends PersonalizationAdapter<ImportConfig> {
     );
 
     if (!existsSync(versionsPath)) {
+      log.debug(`No versions file found for experience: ${oldExperienceUid}`, this.config.context);
       return;
     }
 
     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,
@@ -189,6 +205,7 @@ export default class Experiences extends PersonalizationAdapter<ImportConfig> {
 
       if (versionReqObj && versionReqObj.status) {
         versionMap[versionReqObj.status] = versionReqObj;
+        log.debug(`Mapped version with status: ${versionReqObj.status}`, this.config.context);
       }
     });
 
@@ -201,18 +218,22 @@ export default class Experiences extends PersonalizationAdapter<ImportConfig> {
     experience: ExperienceStruct,
     versionMap: Record<string, CreateExperienceVersionInput | undefined>,
   ) {
+    log.debug(`Handling version update/create for experience: ${experience.uid}`, this.config.context);
     const { ACTIVE, DRAFT, PAUSE } = versionMap;
     let latestVersionUsed = false;
 
     if (ACTIVE) {
+      log.debug(`Updating experience version to ACTIVE for: ${experience.uid}`, this.config.context);
       await this.updateExperienceVersion(experience.uid, experience.latestVersion, ACTIVE);
       latestVersionUsed = true;
     }
 
     if (DRAFT) {
       if (latestVersionUsed) {
+        log.debug(`Creating new DRAFT version for: ${experience.uid}`, this.config.context);
         await this.createExperienceVersion(experience.uid, DRAFT);
       } else {
+        log.debug(`Updating experience version to DRAFT for: ${experience.uid}`, this.config.context);
         await this.updateExperienceVersion(experience.uid, experience.latestVersion, DRAFT);
         latestVersionUsed = true;
       }
@@ -220,8 +241,10 @@ export default class Experiences extends PersonalizationAdapter<ImportConfig> {
 
     if (PAUSE) {
       if (latestVersionUsed) {
+        log.debug(`Creating new PAUSE version for: ${experience.uid}`, this.config.context);
         await this.createExperienceVersion(experience.uid, PAUSE);
       } else {
+        log.debug(`Updating experience version to PAUSE for: ${experience.uid}`, this.config.context);
         await this.updateExperienceVersion(experience.uid, experience.latestVersion, PAUSE);
       }
     }
@@ -235,14 +258,20 @@ 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);
+    
     try {
       const promises = this.pendingVariantAndVariantGrpForExperience.map(async (expUid) => {
+        log.debug(`Checking experience: ${expUid}`, this.config.context);
         const expRes = await this.getExperience(expUid);
         const variants = expRes?._cms?.variants ?? {};
         if (expRes?._cms && expRes?._cms?.variantGroup && Object.keys(variants).length > 0) {
+          log.debug(`Found variants and variant group for experience: ${expUid}`, this.config.context);
           this.cmsVariants[expUid] = expRes._cms?.variants ?? {};
           this.cmsVariantGroups[expUid] = expRes._cms?.variantGroup ?? {};
           return expUid; // Return the expUid for filtering later
+        } else {
+          log.debug(`Variants/variant group not ready for experience: ${expUid}`, this.config.context);
         }
       });
 
@@ -251,6 +280,7 @@ export default class Experiences extends PersonalizationAdapter<ImportConfig> {
 
       if (this.pendingVariantAndVariantGrpForExperience?.length) {
         if (retryCount !== this.maxValidateRetry) {
+          log.debug(`Waiting ${this.expCheckIntervalDuration}ms before retry`, this.config.context);
           await this.delay(this.expCheckIntervalDuration);
           // Filter out the processed elements
           this.pendingVariantAndVariantGrpForExperience = this.pendingVariantAndVariantGrpForExperience.filter(
@@ -258,65 +288,89 @@ export default class Experiences extends PersonalizationAdapter<ImportConfig> {
           );
           return this.validateVariantGroupAndVariantsCreated(retryCount);
         } else {
-          this.log(this.config, this.messages.PERSONALIZE_JOB_FAILURE, 'error');
+          log.error('Personalize job failed to create variants and variant groups', this.config.context);
+          log.error(`Failed experiences: ${this.pendingVariantAndVariantGrpForExperience.join(', ')}`, this.config.context);
           fsUtil.writeFile(this.failedCmsExpPath, this.pendingVariantAndVariantGrpForExperience);
           return false;
         }
       } else {
+        log.debug('All variant groups and variants created successfully', this.config.context);
         return true;
       }
     } catch (error) {
-      this.log(this.config, `Error while validating variant group and variants creation:`, 'error');
+      handleAndLogError(error, this.config.context);
       throw error;
     }
   }
 
   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;
       if (!this.createdCTs) {
-        this.log(this.config, 'No Content types created, skipping following process', 'error');
+        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);
               const { variant_groups: [variantGroup] = [] } =
                 (await this.getVariantGroup({ experienceUid: newExpUid })) || {};
               variantGroup.content_types = updatedContentTypes;
               // Update content types detail in the new experience asynchronously
               return await this.updateVariantGroup(variantGroup);
+            } else {
+              log.debug(`No valid content types found for experience: ${newExpUid}`, this.config.context);
             }
+          } else {
+            log.debug(`No content types mapped for experience: ${oldExpUid}`, this.config.context);
           }
         }),
       );
     } catch (error) {
-      this.log(this.config, `Error while attaching content type with experience`, 'error');
-      this.log(this.config, error, 'error');
+      handleAndLogError(error, this.config.context, 'Failed to attach content type with experience');
     }
   }
 
   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('-');
         const latestVariantId = this.cmsVariants[this.experiencesUidMapper[experienceId]]?.[variantShortId];
         if (latestVariantId) {
           variantUIDMapper[oldVariantId] = latestVariantId;
+          log.debug(`Mapped variant ID: ${oldVariantId} -> ${latestVariantId}`, this.config.context);
+        } else {
+          log.warn(`Could not find variant ID mapping for: ${experienceVariantId}`, this.config.context);
         }
       }
 
+      log.debug(`Created ${Object.keys(variantUIDMapper).length} variant ID mappings`, this.config.context);
       fsUtil.writeFile(this.variantUidMapperFilePath, variantUIDMapper);
+      log.debug(`Variant ID mapper saved to: ${this.variantUidMapperFilePath}`, this.config.context);
     } catch (error) {
+      handleAndLogError(error, this.config.context, 'Failed to create variant ID mapper');
       throw error;
     }
   }