@contentstack/cli-variants 1.2.2 → 1.3.0

package/src/export/attributes.ts

@@ -1,7 +1,7 @@
 import omit from 'lodash/omit';
 import { resolve as pResolve } from 'node:path';
-import { sanitizePath } from '@contentstack/cli-utilities';
-import { formatError, fsUtil, PersonalizationAdapter, log } from '../utils';
+import { sanitizePath, log, handleAndLogError } from '@contentstack/cli-utilities';
+import {fsUtil, PersonalizationAdapter } from '../utils';
 import { PersonalizeConfig, ExportConfig, AttributesConfig, AttributeStruct } from '../types';
 
 export default class ExportAttributes extends PersonalizationAdapter<ExportConfig> {
@@ -16,6 +16,7 @@ export default class ExportAttributes extends PersonalizationAdapter<ExportConfi
       baseURL: exportConfig.modules.personalize.baseURL[exportConfig.region.name],
       headers: { 'X-Project-Uid': exportConfig.project_id },
     });
+    this.exportConfig = exportConfig;
     this.personalizeConfig = exportConfig.modules.personalize;
     this.attributesConfig = exportConfig.modules.attributes;
     this.attributesFolderPath = pResolve(
@@ -25,28 +26,46 @@ export default class ExportAttributes extends PersonalizationAdapter<ExportConfi
       sanitizePath(this.attributesConfig.dirName),
     );
     this.attributes = [];
+    this.exportConfig.context.module = 'attributes';
   }
 
   async start() {
     try {
-      log(this.exportConfig, 'Starting attributes export', 'info');
+      log.info('Starting attributes 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 attributes directory at: ${this.attributesFolderPath}`, this.exportConfig.context);
       await fsUtil.makeDirectory(this.attributesFolderPath);
+      log.debug('Attributes directory created successfully', this.exportConfig.context);
+      
+      log.debug('Fetching attributes from personalization API...', this.exportConfig.context);
       this.attributes = (await this.getAttributes()) as AttributeStruct[];
+      log.debug(`Fetched ${this.attributes?.length || 0} attributes`, this.exportConfig.context);
 
       if (!this.attributes?.length) {
-        log(this.exportConfig, 'No Attributes found with the given project!', 'info');
+        log.debug('No attributes found, completing export', this.exportConfig.context);
+        log.info('No Attributes found with the given project!', this.exportConfig.context);
       } else {
+        log.debug(`Processing ${this.attributes.length} attributes`, this.exportConfig.context);
         this.sanitizeAttribs();
-        fsUtil.writeFile(
-          pResolve(sanitizePath(this.attributesFolderPath), sanitizePath(this.attributesConfig.fileName)),
-          this.attributes,
+        log.debug('Attributes sanitization completed', this.exportConfig.context);
+        
+        const attributesFilePath = pResolve(sanitizePath(this.attributesFolderPath), sanitizePath(this.attributesConfig.fileName));
+        log.debug(`Writing attributes to: ${attributesFilePath}`, this.exportConfig.context);
+        fsUtil.writeFile(attributesFilePath, this.attributes);
+        
+        log.debug('Attributes export completed successfully', this.exportConfig.context);
+        log.success(
+          `Attributes exported successfully! Total attributes: ${this.attributes.length}`,
+          this.exportConfig.context,
         );
-        log(this.exportConfig, 'All the attributes have been exported successfully!', 'success');
       }
     } catch (error) {
-      log(this.exportConfig, `Failed to export attributes!`, 'error');
-      log(this.config, error, 'error');
+      log.debug(`Error occurred during attributes export: ${error}`, this.exportConfig.context);
+      handleAndLogError(error, { ...this.exportConfig.context });
     }
   }
 
@@ -54,6 +73,11 @@ export default class ExportAttributes extends PersonalizationAdapter<ExportConfi
    * function to remove invalid keys from attributes object
    */
   sanitizeAttribs() {
+    log.debug(`Sanitizing ${this.attributes?.length || 0} attributes`, this.exportConfig.context);
+    log.debug(`Invalid keys to remove: ${JSON.stringify(this.attributesConfig.invalidKeys)}`, this.exportConfig.context);
+    
     this.attributes = this.attributes?.map((audience) => omit(audience, this.attributesConfig.invalidKeys)) || [];
+    
+    log.debug(`Sanitization complete. Total attributes after sanitization: ${this.attributes.length}`, this.exportConfig.context);
   }
 }

package/src/export/audiences.ts

@@ -1,7 +1,8 @@
 import omit from 'lodash/omit';
 import { resolve as pResolve } from 'node:path';
+import { log, handleAndLogError } from '@contentstack/cli-utilities';
 
-import { formatError, fsUtil, PersonalizationAdapter, log } from '../utils';
+import { fsUtil, PersonalizationAdapter } from '../utils';
 import { PersonalizeConfig, ExportConfig, AudienceStruct, AudiencesConfig } from '../types';
 
 export default class ExportAudiences extends PersonalizationAdapter<ExportConfig> {
@@ -25,27 +26,49 @@ export default class ExportAudiences extends PersonalizationAdapter<ExportConfig
       this.audiencesConfig.dirName,
     );
     this.audiences = [];
+    this.exportConfig.context.module = 'audiences';
   }
 
   async start() {
     try {
-      log(this.exportConfig, 'Starting audiences export', 'info');
+      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);
 
       if (!this.audiences?.length) {
-        log(this.exportConfig, 'No Audiences found with the given project!', 'info');
+        log.debug('No audiences found, completing export', this.exportConfig.context);
+        log.info('No Audiences found with the given project!', this.exportConfig.context);
         return;
       } else {
+        log.debug(`Processing ${this.audiences.length} audiences`, this.exportConfig.context);
         this.sanitizeAttribs();
-        fsUtil.writeFile(pResolve(this.audiencesFolderPath, this.audiencesConfig.fileName), this.audiences);
-        log(this.exportConfig, 'All the audiences have been exported successfully!', 'success');
+        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;
       }
     } catch (error) {
-      log(this.exportConfig, `Failed to export audiences!`, 'error');
-      log(this.config, error, 'error');
+      log.debug(`Error occurred during audiences export: ${error}`, this.exportConfig.context);
+      handleAndLogError(error, { ...this.exportConfig.context });
     }
   }
 
@@ -53,6 +76,11 @@ export default class ExportAudiences extends PersonalizationAdapter<ExportConfig
    * function to remove invalid keys from audience object
    */
   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);
   }
 }

package/src/export/events.ts

@@ -1,7 +1,8 @@
 import omit from 'lodash/omit';
 import { resolve as pResolve } from 'node:path';
+import { log, handleAndLogError } from '@contentstack/cli-utilities';
 
-import { formatError, fsUtil, PersonalizationAdapter, log } from '../utils';
+import { fsUtil, PersonalizationAdapter } from '../utils';
 import { PersonalizeConfig, ExportConfig, EventStruct, EventsConfig } from '../types';
 
 export default class ExportEvents extends PersonalizationAdapter<ExportConfig> {
@@ -25,27 +26,49 @@ export default class ExportEvents extends PersonalizationAdapter<ExportConfig> {
       this.eventsConfig.dirName,
     );
     this.events = [];
+    this.exportConfig.context.module = 'events';
   }
 
   async start() {
     try {
-      log(this.exportConfig, 'Starting events export', 'info');
+      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);
 
       if (!this.events?.length) {
-        log(this.exportConfig, 'No Events found with the given project!', 'info');
+        log.debug('No events found, completing export', this.exportConfig.context);
+        log.info('No Events found with the given project!', this.exportConfig.context);
         return;
       } else {
+        log.debug(`Processing ${this.events.length} events`, this.exportConfig.context);
         this.sanitizeAttribs();
-        fsUtil.writeFile(pResolve(this.eventsFolderPath, this.eventsConfig.fileName), this.events);
-        log(this.exportConfig, 'All the events have been exported successfully!', 'success');
+        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;
       }
     } catch (error) {
-      log(this.exportConfig, `Failed to export events!`, 'error');
-      log(this.config, error, 'error');
+      log.debug(`Error occurred during events export: ${error}`, this.exportConfig.context);
+      handleAndLogError(error, { ...this.exportConfig.context });
     }
   }
 
@@ -53,6 +76,11 @@ export default class ExportEvents extends PersonalizationAdapter<ExportConfig> {
    * function to remove invalid keys from event object
    */
   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);
   }
 }

package/src/export/experiences.ts

@@ -1,7 +1,7 @@
 import * as path from 'path';
-import { sanitizePath } from '@contentstack/cli-utilities';
+import { sanitizePath, log, handleAndLogError } from '@contentstack/cli-utilities';
 import { PersonalizeConfig, ExportConfig, ExperienceStruct } from '../types';
-import { formatError, fsUtil, log, PersonalizationAdapter } from '../utils';
+import { fsUtil, PersonalizationAdapter } from '../utils';
 
 export default class ExportExperiences extends PersonalizationAdapter<ExportConfig> {
   private experiencesFolderPath: string;
@@ -25,6 +25,7 @@ export default class ExportExperiences extends PersonalizationAdapter<ExportConf
       sanitizePath(this.personalizeConfig.dirName),
       'experiences',
     );
+    this.exportConfig.context.module = 'experiences';
   }
 
   async start() {
@@ -32,66 +33,115 @@ export default class ExportExperiences extends PersonalizationAdapter<ExportConf
       // get all experiences
       // loop through experiences and get content types attached to it
       // write experiences in to a file
-      log(this.exportConfig, 'Starting experiences export', 'info');
+      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);
-      await fsUtil.makeDirectory(path.resolve(sanitizePath(this.experiencesFolderPath), 'versions'));
+      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);
+      
       if (!experiences || experiences?.length < 1) {
-        log(this.exportConfig, 'No Experiences found with the give project', 'info');
+        log.debug('No experiences found, completing export', this.exportConfig.context);
+        log.info('No Experiences found with the given project!', this.exportConfig.context);
         return;
       }
-      fsUtil.writeFile(path.resolve(sanitizePath(this.experiencesFolderPath), 'experiences.json'), experiences);
+      
+      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);
         });
 
         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) {
-            fsUtil.writeFile(
-              path.resolve(sanitizePath(this.experiencesFolderPath), 'versions', `${experience.uid}.json`),
-              experienceVersions,
-            );
+            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(this.exportConfig, `No versions found for experience ${experience.name}`, 'info');
+            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) {
-          log(this.exportConfig, `Failed to fetch versions of experience ${experience.name}`, '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);
           }
         } catch (error) {
-          log(this.exportConfig, `Failed to fetch content types of experience ${experience.name}`, '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}`
+          );
         }
       }
-      fsUtil.writeFile(
-        path.resolve(sanitizePath(this.experiencesFolderPath), 'experiences-variants-ids.json'),
-        experienceToVariantsStrList,
-      );
+      
+      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);
 
-      fsUtil.writeFile(
-        path.resolve(sanitizePath(this.experiencesFolderPath), 'experiences-content-types.json'),
-        experienceToContentTypesMap,
-      );
-      log(this.exportConfig, 'All the experiences have been exported successfully!', 'success');
+      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);
+      
+      log.debug('Experiences export completed successfully', this.exportConfig.context);
+      log.success('Experiences exported successfully!', this.exportConfig.context);
     } catch (error) {
-      log(this.exportConfig, `Failed to export experiences!`, 'error');
-      log(this.config, error, 'error');
+      log.debug(`Error occurred during experiences export: ${error}`, this.exportConfig.context);
+      handleAndLogError(error, {...this.exportConfig.context});
     }
   }
 }

package/src/export/projects.ts

@@ -1,7 +1,7 @@
 import * as path from 'path';
-import { sanitizePath } from '@contentstack/cli-utilities';
+import { sanitizePath, log } from '@contentstack/cli-utilities';
 import { ExportConfig, PersonalizeConfig } from '../types';
-import { PersonalizationAdapter, log, fsUtil, formatError } from '../utils';
+import { PersonalizationAdapter, fsUtil, } from '../utils';
 
 export default class ExportProjects extends PersonalizationAdapter<ExportConfig> {
   private projectFolderPath: string;
@@ -21,26 +21,50 @@ export default class ExportProjects extends PersonalizationAdapter<ExportConfig>
       sanitizePath(this.personalizeConfig.dirName),
       'projects',
     );
+    this.exportConfig.context.module = 'projects';
   }
 
   async start() {
     try {
-      log(this.exportConfig, 'Starting projects export', 'info');
+      log.debug('Starting projects export process...', this.exportConfig.context);
+      log.info(`Starting projects 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 projects directory at: ${this.projectFolderPath}`, this.exportConfig.context);
       await fsUtil.makeDirectory(this.projectFolderPath);
+      log.debug('Projects directory created successfully', this.exportConfig.context);
+      
+      log.debug(`Fetching projects for stack API key: ${this.exportConfig.apiKey}`, this.exportConfig.context);
       const project = await this.projects({ connectedStackApiKey: this.exportConfig.apiKey });
+      log.debug(`Fetched ${project?.length || 0} projects`, this.exportConfig.context);
+      
       if (!project || project?.length < 1) {
-        log(this.exportConfig, 'No Personalize Project connected with the given stack', 'info');
+        log.debug('No projects found, disabling personalization', this.exportConfig.context);
+        log.info(`No Personalize Project connected with the given stack`, this.exportConfig.context);
         this.exportConfig.personalizationEnabled = false;
         return;
       }
+      
+      log.debug(`Found ${project.length} projects, enabling personalization`, this.exportConfig.context);
       this.exportConfig.personalizationEnabled = true;
       this.exportConfig.project_id = project[0]?.uid;
-      fsUtil.writeFile(path.resolve(sanitizePath(this.projectFolderPath), 'projects.json'), project);
-      log(this.exportConfig, 'Project exported successfully!', 'success');
+      log.debug(`Set project ID: ${project[0]?.uid}`, this.exportConfig.context);
+      
+      const projectsFilePath = path.resolve(sanitizePath(this.projectFolderPath), 'projects.json');
+      log.debug(`Writing projects data to: ${projectsFilePath}`, this.exportConfig.context);
+      fsUtil.writeFile(projectsFilePath, project);
+      
+      log.debug('Projects export completed successfully', this.exportConfig.context);
+      log.success(`Projects exported successfully!`, this.exportConfig.context);
     } catch (error) {
       if (error !== 'Forbidden') {
-        log(this.exportConfig, `Failed to export projects!`, 'error');
+        log.debug(`Error occurred during projects export: ${error}`, this.exportConfig.context);
+        log.error('Failed to export projects!', this.exportConfig.context);
+      } else {
+        log.debug('Projects export forbidden, likely due to permissions', this.exportConfig.context);
       }
       throw error;
     }

package/src/export/variant-entries.ts

@@ -1,10 +1,9 @@
 import { existsSync, mkdirSync } from 'fs';
 import { join, resolve } from 'path';
-import { FsUtility, sanitizePath } from '@contentstack/cli-utilities';
+import { FsUtility, sanitizePath, log, handleAndLogError } from '@contentstack/cli-utilities';
 
-import { APIConfig, AdapterType, ExportConfig, LogType } from '../types';
+import { APIConfig, AdapterType, ExportConfig } from '../types';
 import VariantAdapter, { VariantHttpClient } from '../utils/variant-api-adapter';
-import { fsUtil, log } from '../utils';
 
 export default class VariantEntries extends VariantAdapter<VariantHttpClient<ExportConfig>> {
   public entriesDirPath: string;
@@ -24,7 +23,14 @@ export default class VariantEntries extends VariantAdapter<VariantHttpClient<Exp
       },
     };
     super(Object.assign(config, conf));
-    this.entriesDirPath = resolve(sanitizePath(config.data), sanitizePath(config.branchName || ''), sanitizePath(config.modules.entries.dirName));
+    this.entriesDirPath = resolve(
+      sanitizePath(config.data),
+      sanitizePath(config.branchName || ''),
+      sanitizePath(config.modules.entries.dirName),
+    );
+    if (this.config && this.config.context) {
+      this.config.context.module = 'variant-entries';
+    }
   }
 
   /**
@@ -35,10 +41,27 @@ export default class VariantEntries extends VariantAdapter<VariantHttpClient<Exp
   async exportVariantEntry(options: { locale: string; contentTypeUid: string; entries: Record<string, any>[] }) {
     const variantEntry = this.config.modules.variantEntry;
     const { entries, locale, contentTypeUid: content_type_uid } = options;
+    
+    log.debug(`Starting variant entries export for content type: ${content_type_uid}, locale: ${locale}`, this.config.context);
+    log.debug(`Processing ${entries.length} entries for variant export`, this.config.context);
+    
+    log.debug('Initializing variant instance...', this.config.context);
     await this.variantInstance.init();
+    log.debug('Variant instance initialized successfully', this.config.context);
+    
     for (let index = 0; index < entries.length; index++) {
       const entry = entries[index];
-      const variantEntryBasePath = join(sanitizePath(this.entriesDirPath), sanitizePath(content_type_uid), sanitizePath(locale), sanitizePath(variantEntry.dirName), sanitizePath(entry.uid));
+      log.debug(`Processing variant entries for entry: ${entry.title} (${entry.uid}) - ${index + 1}/${entries.length}`, this.config.context);
+      
+      const variantEntryBasePath = join(
+        sanitizePath(this.entriesDirPath),
+        sanitizePath(content_type_uid),
+        sanitizePath(locale),
+        sanitizePath(variantEntry.dirName),
+        sanitizePath(entry.uid),
+      );
+      log.debug(`Variant entry base path: ${variantEntryBasePath}`, this.config.context);
+      
       const variantEntriesFs = new FsUtility({
         isArray: true,
         keepMetadata: false,
@@ -48,17 +71,24 @@ export default class VariantEntries extends VariantAdapter<VariantHttpClient<Exp
         chunkFileSize: variantEntry.chunkFileSize || 1,
         createDirIfNotExist: false,
       });
+      log.debug('Initialized FsUtility for variant entries', this.config.context);
 
       const callback = (variantEntries: Record<string, any>[]) => {
+        log.debug(`Callback received ${variantEntries?.length || 0} variant entries for entry: ${entry.uid}`, this.config.context);
         if (variantEntries?.length) {
           if (!existsSync(variantEntryBasePath)) {
+            log.debug(`Creating directory: ${variantEntryBasePath}`, this.config.context);
             mkdirSync(variantEntryBasePath, { recursive: true });
           }
+          log.debug(`Writing ${variantEntries.length} variant entries to file`, this.config.context);
           variantEntriesFs.writeIntoFile(variantEntries);
+        } else {
+          log.debug(`No variant entries found for entry: ${entry.uid}`, this.config.context);
         }
       };
 
       try {
+        log.debug(`Fetching variant entries for entry: ${entry.uid}`, this.config.context);
         await this.variantInstance.variantEntries({
           callback,
           getAllData: true,
@@ -66,22 +96,27 @@ export default class VariantEntries extends VariantAdapter<VariantHttpClient<Exp
           entry_uid: entry.uid,
           locale,
         });
+        
         if (existsSync(variantEntryBasePath)) {
+          log.debug(`Completing file for entry: ${entry.uid}`, this.config.context);
           variantEntriesFs.completeFile(true);
-          log(
-            this.config,
+          log.info(
             `Exported variant entries of type '${entry.title} (${entry.uid})' locale '${locale}'`,
-            'info',
+            this.config.context,
           );
+        } else {
+          log.debug(`No variant entries directory created for entry: ${entry.uid}`, this.config.context);
         }
       } catch (error) {
-        log(
-          this.config,
+        log.debug(`Error occurred while exporting variant entries for entry: ${entry.uid}`, this.config.context);
+        handleAndLogError(
+          error,
+          { ...this.config.context },
           `Error exporting variant entries of type '${entry.title} (${entry.uid})' locale '${locale}'`,
-          'error',
         );
-        log(this.config, error, 'error');
       }
     }
+    
+    log.debug(`Completed variant entries export for content type: ${content_type_uid}, locale: ${locale}`, this.config.context);
   }
 }