@contentstack/cli-variants 1.3.3 → 2.0.0-beta

package/src/export/projects.ts

@@ -1,12 +1,15 @@
-import * as path from 'path';
-import { sanitizePath, log } from '@contentstack/cli-utilities';
-import { ExportConfig, PersonalizeConfig } from '../types';
-import { PersonalizationAdapter, fsUtil, } from '../utils';
+import { resolve as pResolve } from 'node:path';
+import { sanitizePath, log, handleAndLogError } from '@contentstack/cli-utilities';
+import { PersonalizeConfig, ExportConfig, ProjectStruct } from '../types';
+import { fsUtil, PersonalizationAdapter } from '../utils';
+import { PROCESS_NAMES, MODULE_CONTEXTS, EXPORT_PROCESS_STATUS } from '../utils/constants';
 
 export default class ExportProjects extends PersonalizationAdapter<ExportConfig> {
-  private projectFolderPath: string;
+  private projectsFolderPath: string;
+  private projectsData: ProjectStruct[];
   public exportConfig: ExportConfig;
   public personalizeConfig: PersonalizeConfig;
+
   constructor(exportConfig: ExportConfig) {
     super({
       config: exportConfig,
@@ -15,57 +18,86 @@ export default class ExportProjects extends PersonalizationAdapter<ExportConfig>
     });
     this.exportConfig = exportConfig;
     this.personalizeConfig = exportConfig.modules.personalize;
-    this.projectFolderPath = path.resolve(
+    this.projectsFolderPath = pResolve(
       sanitizePath(exportConfig.data),
       sanitizePath(exportConfig.branchName || ''),
       sanitizePath(this.personalizeConfig.dirName),
       'projects',
     );
-    this.exportConfig.context.module = 'projects';
+    this.projectsData = [];
+    this.exportConfig.context.module = MODULE_CONTEXTS.PROJECTS;
   }
 
   async start() {
     try {
       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.info('Starting projects export', this.exportConfig.context);
+
+      // Initial setup with loading spinner
+      await this.withLoadingSpinner('PROJECTS: Initializing export and fetching data...', async () => {
+        log.debug('Initializing personalization adapter...', this.exportConfig.context);
+        await this.init();
+        log.debug('Personalization adapter initialized successfully', this.exportConfig.context);
+
+        log.debug(`Creating projects directory at: ${this.projectsFolderPath}`, this.exportConfig.context);
+        await fsUtil.makeDirectory(this.projectsFolderPath);
+        log.debug('Projects directory created successfully', this.exportConfig.context);
+
+        log.debug('Fetching projects from personalization API...', this.exportConfig.context);
+        // talisman-ignore-line
+        this.projectsData = (await this.projects({ connectedStackApiKey: this.exportConfig.apiKey })) || [];
+        log.debug(`Fetched ${this.projectsData?.length || 0} projects`, this.exportConfig.context);
+      });
+
+      if (!this.projectsData?.length) {
         log.debug('No projects found, disabling personalization', this.exportConfig.context);
-        log.info(`No Personalize Project connected with the given stack`, 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);
+
+      // Enable personalization and set project config
+      log.debug(`Found ${this.projectsData.length} projects, enabling personalization`, this.exportConfig.context);
       this.exportConfig.personalizationEnabled = true;
-      this.exportConfig.project_id = project[0]?.uid;
-      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.debug(`Error occurred during projects export: ${error}`, this.exportConfig.context);
-        log.error('Failed to export projects!', this.exportConfig.context);
+      this.exportConfig.project_id = this.projectsData[0]?.uid;
+      log.debug(`Set project ID: ${this.projectsData[0]?.uid}`, this.exportConfig.context);
+
+      let progress: any;
+      if (this.parentProgressManager) {
+        progress = this.parentProgressManager;
+        this.progressManager = this.parentProgressManager;
+        // Parent already has correct count, just update status
+        progress.updateStatus(EXPORT_PROCESS_STATUS[PROCESS_NAMES.PROJECTS].EXPORTING, PROCESS_NAMES.PROJECTS);
       } else {
-        log.debug('Projects export forbidden, likely due to permissions', this.exportConfig.context);
+        progress = this.createNestedProgress(PROCESS_NAMES.PROJECTS);
+        progress.addProcess(PROCESS_NAMES.PROJECTS, this.projectsData?.length);
+        progress
+          .startProcess(PROCESS_NAMES.PROJECTS)
+          .updateStatus(EXPORT_PROCESS_STATUS[PROCESS_NAMES.PROJECTS].EXPORTING, PROCESS_NAMES.PROJECTS);
       }
+
+      const projectsFilePath = pResolve(sanitizePath(this.projectsFolderPath), 'projects.json');
+      log.debug(`Writing projects to: ${projectsFilePath}`, this.exportConfig.context);
+      fsUtil.writeFile(projectsFilePath, this.projectsData);
+      log.debug('Projects export completed successfully', this.exportConfig.context);
+
+      const processName = PROCESS_NAMES.PROJECTS;
+      this.updateProgress(true, 'project export', undefined, processName);
+
+      // Complete process only if we're managing our own progress
+      if (!this.parentProgressManager) {
+        progress.completeProcess(PROCESS_NAMES.PROJECTS, true);
+        this.completeProgress(true);
+      }
+
+      log.success(
+        `Projects exported successfully! Total projects: ${this.projectsData.length} - personalization enabled`,
+        this.exportConfig.context,
+      );
+    } catch (error: any) {
+      log.debug(`Error occurred during projects export: ${error}`, this.exportConfig.context);
+      this.completeProgress(false, error?.message || 'Projects export failed');
+      handleAndLogError(error, { ...this.exportConfig.context });
       throw error;
     }
   }

package/src/export/variant-entries.ts

@@ -1,6 +1,7 @@
 import { existsSync, mkdirSync } from 'fs';
 import { join, resolve } from 'path';
-import { FsUtility, sanitizePath, log, handleAndLogError } from '@contentstack/cli-utilities';
+import { FsUtility, sanitizePath, log, handleAndLogError, CLIProgressManager } from '@contentstack/cli-utilities';
+import { PROCESS_NAMES, EXPORT_PROCESS_STATUS } from '../utils/constants';
 
 import { APIConfig, AdapterType, ExportConfig } from '../types';
 import VariantAdapter, { VariantHttpClient } from '../utils/variant-api-adapter';
@@ -8,6 +9,12 @@ import VariantAdapter, { VariantHttpClient } from '../utils/variant-api-adapter'
 export default class VariantEntries extends VariantAdapter<VariantHttpClient<ExportConfig>> {
   public entriesDirPath: string;
   public variantEntryBasePath!: string;
+  protected progressManager: CLIProgressManager | null = null;
+  protected parentProgressManager: CLIProgressManager | null = null;
+  public progress: any;
+  private processInitialized: boolean = false;
+  private totalVariantCount: number = 0;
+  private processedVariantCount: number = 0;
 
   constructor(readonly config: ExportConfig) {
     const conf: APIConfig & AdapterType<VariantHttpClient<ExportConfig>, APIConfig> = {
@@ -33,6 +40,39 @@ export default class VariantEntries extends VariantAdapter<VariantHttpClient<Exp
     }
   }
 
+  /**
+   * Set parent progress manager for integration with entries module
+   */
+  public setParentProgressManager(parentProgress: CLIProgressManager): void {
+    this.parentProgressManager = parentProgress;
+    this.progressManager = parentProgress;
+    this.progress = parentProgress;
+  }
+
+  /**
+   * Update progress for a specific item
+   */
+  protected updateProgress(success: boolean, itemName: string, error?: string, processName?: string): void {
+    if (this.progress) {
+      this.progress.tick(success, itemName, error, processName);
+    }
+  }
+
+  /**
+   * Complete the variant entries export process
+   */
+  public completeExport(): void {
+    if (this.processInitialized && this.progress) {
+      this.progress.completeProcess(PROCESS_NAMES.VARIANT_ENTRIES, true);
+      log.success(
+        `Completed export of ${this.totalVariantCount} variant entries across all content types and locales`,
+        this.config.context,
+      );
+    } else if (this.totalVariantCount === 0) {
+      log.info(`No variant entries found for export`, this.config.context);
+    }
+  }
+
   /**
    * This function exports variant entries for a specific content type and locale.
    * @param options - The `exportVariantEntry` function takes in an `options` object with the following
@@ -41,18 +81,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(
+      `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);
-    
+
+    let localVariantCount = 0; // Track variants found in this specific call
+    let processedEntries = 0;
+
     for (let index = 0; index < entries.length; index++) {
       const entry = entries[index];
-      log.debug(`Processing variant entries for entry: ${entry.title} (${entry.uid}) - ${index + 1}/${entries.length}`, this.config.context);
-      
+      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),
@@ -61,7 +110,7 @@ export default class VariantEntries extends VariantAdapter<VariantHttpClient<Exp
         sanitizePath(entry.uid),
       );
       log.debug(`Variant entry base path: ${variantEntryBasePath}`, this.config.context);
-      
+
       const variantEntriesFs = new FsUtility({
         isArray: true,
         keepMetadata: false,
@@ -73,9 +122,38 @@ export default class VariantEntries extends VariantAdapter<VariantHttpClient<Exp
       });
       log.debug('Initialized FsUtility for variant entries', this.config.context);
 
+      let entryHasVariants = false;
+      let variantCount = 0;
+
       const callback = (variantEntries: Record<string, any>[]) => {
-        log.debug(`Callback received ${variantEntries?.length || 0} variant entries for entry: ${entry.uid}`, this.config.context);
+        log.debug(
+          `Callback received ${variantEntries?.length || 0} variant entries for entry: ${entry.uid}`,
+          this.config.context,
+        );
         if (variantEntries?.length) {
+          log.info(`Fetched ${variantEntries.length} variant entries for entry: ${entry.uid}`, this.config.context);
+          entryHasVariants = true;
+          variantCount = variantEntries.length;
+          localVariantCount += variantCount;
+          this.totalVariantCount += variantCount;
+
+          // Initialize progress ONLY when we find the first variants globally (lazy initialization)
+          if (!this.processInitialized && this.progress) {
+            this.progress.addProcess(PROCESS_NAMES.VARIANT_ENTRIES, variantCount);
+            this.progress.startProcess(PROCESS_NAMES.VARIANT_ENTRIES);
+            this.processInitialized = true;
+            log.debug(
+              `Initialized variant entries progress with first batch of ${variantCount} variants`,
+              this.config.context,
+            );
+          }
+
+          // Update total as we discover more variants globally
+          if (this.processInitialized && this.progress) {
+            this.progress.updateProcessTotal(PROCESS_NAMES.VARIANT_ENTRIES, this.totalVariantCount);
+            log.debug(`Updated progress total to: ${this.totalVariantCount}`, this.config.context);
+          }
+
           if (!existsSync(variantEntryBasePath)) {
             log.debug(`Creating directory: ${variantEntryBasePath}`, this.config.context);
             mkdirSync(variantEntryBasePath, { recursive: true });
@@ -96,7 +174,7 @@ 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);
@@ -107,8 +185,39 @@ export default class VariantEntries extends VariantAdapter<VariantHttpClient<Exp
         } else {
           log.debug(`No variant entries directory created for entry: ${entry.uid}`, this.config.context);
         }
+
+        // After processing this entry, update progress for variants found
+        if (entryHasVariants && this.processInitialized) {
+          // Tick progress for each variant found in this entry
+          for (let i = 0; i < variantCount; i++) {
+            this.processedVariantCount++;
+            this.updateProgress(
+              true,
+              `Exported variant ${this.processedVariantCount}/${this.totalVariantCount} from ${entry.title || entry.uid}`,
+              undefined,
+              PROCESS_NAMES.VARIANT_ENTRIES,
+            );
+          }
+          log.debug(
+            `Processed ${variantCount} variants for entry: ${entry.uid}, total processed: ${this.processedVariantCount}/${this.totalVariantCount}`,
+            this.config.context,
+          );
+        }
+
+        processedEntries++;
       } catch (error) {
         log.debug(`Error occurred while exporting variant entries for entry: ${entry.uid}`, this.config.context);
+
+        // Track progress for failed entry
+        if (this.processInitialized) {
+          this.updateProgress(
+            false,
+            `Failed to export variants for entry: ${entry.title || entry.uid}`,
+            (error as any)?.message || 'Unknown error',
+            PROCESS_NAMES.VARIANT_ENTRIES,
+          );
+        }
+
         handleAndLogError(
           error,
           { ...this.config.context },
@@ -116,7 +225,22 @@ export default class VariantEntries extends VariantAdapter<VariantHttpClient<Exp
         );
       }
     }
-    
-    log.debug(`Completed variant entries export for content type: ${content_type_uid}, locale: ${locale}`, this.config.context);
+
+    if (localVariantCount > 0) {
+      log.success(
+        `Exported ${localVariantCount} variant entries across ${processedEntries} entries for ${content_type_uid}/${locale}`,
+        this.config.context,
+      );
+    } else {
+      log.info(
+        `No variant entries found for content type: ${content_type_uid}, locale: ${locale}`,
+        this.config.context,
+      );
+    }
+
+    log.debug(
+      `Completed variant entries export for content type: ${content_type_uid}, locale: ${locale}. Local variants: ${localVariantCount}, Total variants so far: ${this.totalVariantCount}, Processed entries: ${processedEntries}`,
+      this.config.context,
+    );
   }
 }

package/src/import/attribute.ts

@@ -3,6 +3,7 @@ import { existsSync } from 'fs';
 import { sanitizePath, log, handleAndLogError } from '@contentstack/cli-utilities';
 import { PersonalizationAdapter, fsUtil } from '../utils';
 import { APIConfig, AttributeStruct, ImportConfig, LogType } from '../types';
+import { PROCESS_NAMES, MODULE_CONTEXTS, IMPORT_PROCESS_STATUS } from '../utils/constants';
 
 export default class Attribute extends PersonalizationAdapter<ImportConfig> {
   private mapperDirPath: string;
@@ -11,15 +12,16 @@ export default class Attribute extends PersonalizationAdapter<ImportConfig> {
   private attributesUidMapper: Record<string, unknown>;
   private personalizeConfig: ImportConfig['modules']['personalize'];
   private attributeConfig: ImportConfig['modules']['personalize']['attributes'];
+  private attributeData: AttributeStruct[];
 
-  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.attributeConfig = this.personalizeConfig.attributes;
     this.mapperDirPath = resolve(
@@ -30,62 +32,116 @@ 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';
+    this.config.context.module = MODULE_CONTEXTS.ATTRIBUTES;
+    this.attributeData = [];
   }
 
   /**
    * The function asynchronously imports attributes from a JSON file and creates them in the system.
    */
-  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),
-      sanitizePath(this.personalizeConfig.dirName),
-      sanitizePath(dirName),
-      sanitizePath(fileName),
-    );
+  async import() {
+    try {
+      log.debug('Starting attributes import...', this.config.context);
+
+      const [canImport, attributesCount] = await this.analyzeAttributes();
+      if (!canImport) {
+        log.info('No attributes found to import', this.config.context);
+        // Still need to mark as complete for parent progress
+        if (this.parentProgressManager) {
+          this.parentProgressManager.tick(true, 'attributes module (no data)', null, PROCESS_NAMES.ATTRIBUTES);
+        }
+        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 attributes import', this.config.context);
+        this.parentProgressManager.updateProcessTotal(PROCESS_NAMES.ATTRIBUTES, attributesCount);
+
+      } else {
+        progress = this.createSimpleProgress(PROCESS_NAMES.ATTRIBUTES, attributesCount);
+        log.debug('Created standalone progress manager for attributes import', this.config.context);
+      }
+
+      await this.init();
+      await fsUtil.makeDirectory(this.attrMapperDirPath);
+      log.debug(`Created mapper directory: ${this.attrMapperDirPath}`, this.config.context);
+
+      const { dirName, fileName } = this.attributeConfig;
+      log.info(`Processing ${attributesCount} attributes`, this.config.context);
+
+      for (const attribute of this.attributeData) {
+        const { key, name, description, uid } = attribute;
+        if (!this.parentProgressManager) {
+          progress.updateStatus(IMPORT_PROCESS_STATUS[PROCESS_NAMES.ATTRIBUTES].CREATING);
+        }
+        log.debug(`Processing attribute: ${name} - ${attribute.__type}`, this.config.context);
 
-    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) {
-            handleAndLogError(error, this.config.context, `Failed to create attribute: ${name}`);
-          }
+        // 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);
+          this.updateProgress(true, `attribute: ${name} (preset - skipped)`, undefined, PROCESS_NAMES.ATTRIBUTES);
+          continue;
         }
 
-        fsUtil.writeFile(this.attributesUidMapperPath, this.attributesUidMapper);
-        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) {
-        handleAndLogError(error, this.config.context);
+        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 ?? '';
+
+          this.updateProgress(true, `attribute: ${name}`, undefined, PROCESS_NAMES.ATTRIBUTES);
+          log.debug(`Created attribute: ${uid} -> ${attributeRes?.uid}`, this.config.context);
+        } catch (error) {
+          this.updateProgress(false, `attribute: ${name}`, (error as any)?.message, PROCESS_NAMES.ATTRIBUTES);
+          handleAndLogError(error, this.config.context, `Failed to create attribute: ${name}`);
+        }
       }
-    } else {
-      log.warn(`Attributes file not found: ${attributesPath}`, this.config.context);
+
+      fsUtil.writeFile(this.attributesUidMapperPath, this.attributesUidMapper);
+      log.debug(`Saved ${Object.keys(this.attributesUidMapper).length} attribute mappings`, this.config.context);
+
+      if (!this.parentProgressManager) {
+        this.completeProgress(true);
+      }
+      log.success(
+        `Attributes imported successfully! Total attributes: ${attributesCount} - personalization enabled`,
+        this.config.context,
+      );
+    } catch (error) {
+      if (!this.parentProgressManager) {
+        this.completeProgress(false, (error as any)?.message || 'Attributes import failed');
+      }
+      handleAndLogError(error, this.config.context);
+      throw error;
     }
   }
+
+  private async analyzeAttributes(): Promise<[boolean, number]> {
+    return this.withLoadingSpinner('ATTRIBUTES: Analyzing import data...', async () => {
+      const { dirName, fileName } = this.attributeConfig;
+      const attributesPath = resolve(
+        sanitizePath(this.config.data),
+        sanitizePath(this.personalizeConfig.dirName),
+        sanitizePath(dirName),
+        sanitizePath(fileName),
+      );
+
+      log.debug(`Checking for attributes file: ${attributesPath}`, this.config.context);
+
+      if (!existsSync(attributesPath)) {
+        log.warn(`Attributes file not found: ${attributesPath}`, this.config.context);
+        return [false, 0];
+      }
+
+      this.attributeData = fsUtil.readFile(attributesPath, true) as AttributeStruct[];
+      const attributesCount = this.attributeData?.length || 0;
+
+      log.debug(`Found ${attributesCount} attributes to import`, this.config.context);
+      return [attributesCount > 0, attributesCount];
+    });
+  }
 }