@contentstack/cli-variants 1.3.2 → 2.0.0-beta

package/src/import/project.ts

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

package/src/import/variant-entries.ts

@@ -23,6 +23,7 @@ import {
   PublishVariantEntryDto,
 } from '../types';
 import { fsUtil } from '../utils';
+import { PROCESS_NAMES, MODULE_CONTEXTS } from '../utils/constants';
 
 export default class VariantEntries extends VariantAdapter<VariantHttpClient<ImportConfig>> {
   public entriesDirPath: string;
@@ -39,6 +40,8 @@ export default class VariantEntries extends VariantAdapter<VariantHttpClient<Imp
   private failedVariantPath!: string;
   private failedVariantEntries!: Record<string, any>;
   private environments!: Record<string, any>;
+  public progress: any;
+  private processInitialized: boolean = false;
 
   constructor(readonly config: ImportConfig & { helpers?: ImportHelperMethodsConfig }) {
     const conf: APIConfig & AdapterType<VariantHttpClient<ImportConfig>, APIConfig> = {
@@ -61,7 +64,24 @@ export default class VariantEntries extends VariantAdapter<VariantHttpClient<Imp
     this.failedVariantPath = resolve(sanitizePath(this.entriesMapperPath), 'failed-entry-variants.json');
     this.failedVariantEntries = new Map();
     if (this.config && this.config.context) {
-      this.config.context.module = 'variant-entries';
+      this.config.context.module = MODULE_CONTEXTS.VARIANT_ENTRIES;
+    }
+  }
+
+  /**
+   * Set parent progress manager for integration with entries module
+   */
+  public setParentProgressManager(parentProgress: any): void {
+    this.parentProgressManager = 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);
     }
   }
 
@@ -74,87 +94,141 @@ export default class VariantEntries extends VariantAdapter<VariantHttpClient<Imp
    * message indicating that no entries were found and return.
    */
   async import() {
-    const filePath = resolve(sanitizePath(this.entriesMapperPath), 'data-for-variant-entry.json');
-    const variantIdPath = resolve(
-      sanitizePath(this.config.backupDir),
-      'mapper',
-      sanitizePath(this.personalizeConfig.dirName),
-      sanitizePath(this.personalizeConfig.experiences.dirName),
-      'variants-uid-mapping.json',
-    );
+    try {
+      const filePath = resolve(sanitizePath(this.entriesMapperPath), 'data-for-variant-entry.json');
+      const variantIdPath = resolve(
+        sanitizePath(this.config.backupDir),
+        'mapper',
+        sanitizePath(this.personalizeConfig.dirName),
+        sanitizePath(this.personalizeConfig.experiences.dirName),
+        'variants-uid-mapping.json',
+      );
 
-    log.debug(`Checking for variant entry data file: ${filePath}`, this.config.context);
-    if (!existsSync(filePath)) {
-      log.warn(`Variant entry data file not found at path: ${filePath}, skipping import`, this.config.context);
-      return;
-    }
+      log.debug(`Checking for variant entry data file: ${filePath}`, this.config.context);
+      if (!existsSync(filePath)) {
+        log.warn(`Variant entry data file not found at path: ${filePath}, skipping import`, this.config.context);
+        return;
+      }
 
-    log.debug(`Checking for variant ID mapping file: ${variantIdPath}`, this.config.context);
-    if (!existsSync(variantIdPath)) {
-      log.error('Variant UID mapping file not found', this.config.context);
-      return;
-    }
+      log.debug(`Checking for variant ID mapping file: ${variantIdPath}`, this.config.context);
+      if (!existsSync(variantIdPath)) {
+        log.error('Variant UID mapping file not found', this.config.context);
+        return;
+      }
 
-    const entriesForVariants = fsUtil.readFile(filePath, true) as EntryDataForVariantEntries[];
-    log.debug(`Loaded ${entriesForVariants?.length || 0} entries for variant processing`, this.config.context);
+      const entriesForVariants = fsUtil.readFile(filePath, true) as EntryDataForVariantEntries[];
+      log.debug(`Loaded ${entriesForVariants?.length || 0} entries for variant processing`, this.config.context);
 
-    if (isEmpty(entriesForVariants)) {
-      log.warn('No entries found for variant import', this.config.context);
-      return;
-    }
+      if (isEmpty(entriesForVariants)) {
+        log.warn('No entries found for variant import', this.config.context);
+        return;
+      }
 
-    const entriesUidMapperPath = join(sanitizePath(this.entriesMapperPath), 'uid-mapping.json');
-    const assetUidMapperPath = resolve(sanitizePath(this.config.backupDir), 'mapper', 'assets', 'uid-mapping.json');
-    const assetUrlMapperPath = resolve(sanitizePath(this.config.backupDir), 'mapper', 'assets', 'url-mapping.json');
-    const taxonomiesPath = resolve(
-      sanitizePath(this.config.backupDir),
-      'mapper',
-      sanitizePath(this.config.modules.taxonomies.dirName),
-      'terms',
-      'success.json',
-    );
-    const marketplaceAppMapperPath = resolve(
-      sanitizePath(this.config.backupDir),
-      'mapper',
-      'marketplace_apps',
-      'uid-mapping.json',
-    );
-    const envPath = resolve(sanitizePath(this.config.backupDir), 'environments', 'environments.json');
+      const entriesUidMapperPath = join(sanitizePath(this.entriesMapperPath), 'uid-mapping.json');
+      const assetUidMapperPath = resolve(sanitizePath(this.config.backupDir), 'mapper', 'assets', 'uid-mapping.json');
+      const assetUrlMapperPath = resolve(sanitizePath(this.config.backupDir), 'mapper', 'assets', 'url-mapping.json');
+      const taxonomiesPath = resolve(
+        sanitizePath(this.config.backupDir),
+        'mapper',
+        sanitizePath(this.config.modules.taxonomies.dirName),
+        'terms',
+        'success.json',
+      );
+      const marketplaceAppMapperPath = resolve(
+        sanitizePath(this.config.backupDir),
+        'mapper',
+        'marketplace_apps',
+        'uid-mapping.json',
+      );
+      const envPath = resolve(sanitizePath(this.config.backupDir), 'environments', 'environments.json');
 
-    log.debug('Loading variant ID mapping and dependency data', this.config.context);
+      log.debug('Loading variant ID mapping and dependency data', this.config.context);
 
-    // NOTE Read and store list of variant IDs
-    this.variantIdList = (fsUtil.readFile(variantIdPath, true) || {}) as Record<string, unknown>;
-    if (isEmpty(this.variantIdList)) {
-      log.warn('Empty variant UID data found', this.config.context);
-      return;
-    }
+      // NOTE Read and store list of variant IDs
+      this.variantIdList = (fsUtil.readFile(variantIdPath, true) || {}) as Record<string, unknown>;
+      if (isEmpty(this.variantIdList)) {
+        log.warn('Empty variant UID data found', this.config.context);
+        return;
+      }
 
-    // NOTE entry relational data lookup dependencies.
-    this.entriesUidMapper = (fsUtil.readFile(entriesUidMapperPath, true) || {}) as Record<string, any>;
-    this.installedExtensions = ((fsUtil.readFile(marketplaceAppMapperPath) as any) || { extension_uid: {} })
-      .extension_uid as Record<string, any>[];
-    this.taxonomies = (fsUtil.readFile(taxonomiesPath, true) || {}) as Record<string, unknown>;
-    this.assetUidMapper = (fsUtil.readFile(assetUidMapperPath, true) || {}) as Record<string, any>;
-    this.assetUrlMapper = (fsUtil.readFile(assetUrlMapperPath, true) || {}) as Record<string, any>;
-    this.environments = (fsUtil.readFile(envPath, true) || {}) as Record<string, any>;
+      // NOTE entry relational data lookup dependencies.
+      this.entriesUidMapper = (fsUtil.readFile(entriesUidMapperPath, true) || {}) as Record<string, any>;
+      this.installedExtensions = ((fsUtil.readFile(marketplaceAppMapperPath) as any) || { extension_uid: {} })
+        .extension_uid as Record<string, any>[];
+      this.taxonomies = (fsUtil.readFile(taxonomiesPath, true) || {}) as Record<string, unknown>;
+      this.assetUidMapper = (fsUtil.readFile(assetUidMapperPath, true) || {}) as Record<string, any>;
+      this.assetUrlMapper = (fsUtil.readFile(assetUrlMapperPath, true) || {}) as Record<string, any>;
+      this.environments = (fsUtil.readFile(envPath, true) || {}) as Record<string, any>;
 
     log.debug(
-      `Loaded dependency data - Entries: ${Object.keys(this.entriesUidMapper).length}, Assets: ${
-        Object.keys(this.assetUidMapper).length
-      }, Taxonomies: ${Object.keys(this.taxonomies).length}`,
+      `Loaded dependency data - Entries: ${Object.keys(this.entriesUidMapper)?.length}, Assets: ${
+        Object.keys(this.assetUidMapper)?.length
+      }, Taxonomies: ${Object.keys(this.taxonomies)?.length}`,
       this.config.context,
     );
 
-    // set the token
-    await this.variantInstance.init();
+      // Initialize progress manager - will be set up lazily when first variants are found
+      if (this.parentProgressManager) {
+        this.progress = this.parentProgressManager;
+        log.debug('Using parent progress manager for variant entries import', this.config.context);
+      } else {
+        this.progress = this.createSimpleProgress(PROCESS_NAMES.VARIANT_ENTRIES);
+        log.debug('Created standalone progress manager for variant entries import', this.config.context);
+      }
 
-    log.info(`Processing ${entriesForVariants.length} entries for variant import`, this.config.context);
-    for (const entriesForVariant of entriesForVariants) {
-      await this.importVariantEntries(entriesForVariant);
-    }
+      // set the token
+      await this.variantInstance.init();
+      log.info(`Processing ${entriesForVariants?.length} entries for variant import`, this.config.context);
+      for (const entriesForVariant of entriesForVariants) {
+        try {
+          await this.importVariantEntries(entriesForVariant);
+          log.debug(
+            `Successfully processed variant entry: ${entriesForVariant.content_type}/${entriesForVariant.locale}/${entriesForVariant.entry_uid}`,
+            this.config.context,
+          );
+        } catch (error) {
+          handleAndLogError(
+            error,
+            this.config.context,
+            `Failed to import variant entry: ${entriesForVariant.content_type}/${entriesForVariant.locale}/${entriesForVariant.entry_uid}`,
+          );
+        }
+      }
+
+      // Complete progress if we initialized it and own the progress manager
+      if (this.processInitialized && this.progress) {
+        const processName = this.parentProgressManager ? 'Variant Entries' : PROCESS_NAMES.VARIANT_ENTRIES;
+        this.progress.completeProcess(processName, true);
+        log.success(
+          `Completed import of variant entries across ${entriesForVariants.length} entries`,
+          this.config.context,
+        );
+      } else if (entriesForVariants.length === 0) {
+        log.info(`No variant entries found for import`, this.config.context);
+      }
+
+      // Only complete overall progress if we own the progress manager (no parent)
+      if (!this.parentProgressManager) {
+        this.completeProgress(true);
+      }
 
-    log.success('All variant entries have been imported and published successfully', this.config.context);
+      log.success(
+        `Variant entries imported successfully! Total entries: ${entriesForVariants.length} - processing completed`,
+        this.config.context,
+      );
+    } catch (error) {
+      // Complete progress with error if we initialized it
+      if (this.processInitialized && this.progress) {
+        const processName = this.parentProgressManager ? 'Variant Entries' : PROCESS_NAMES.VARIANT_ENTRIES;
+        this.progress.completeProcess(processName, false);
+      }
+
+      if (!this.parentProgressManager) {
+        this.completeProgress(false, (error as any)?.message || 'Variant entries import failed');
+      }
+      handleAndLogError(error, this.config.context, 'Variant entries import failed');
+      throw error;
+    }
   }
 
   /**
@@ -163,10 +237,11 @@ export default class VariantEntries extends VariantAdapter<VariantHttpClient<Imp
    * @param {EntryDataForVariantEntries} entriesForVariant - EntryDataForVariantEntries {
    */
   async importVariantEntries(entriesForVariant: EntryDataForVariantEntries) {
+    let totalVariantEntries = 0;
     const variantEntry = this.config.modules.variantEntry;
     const { content_type, locale, entry_uid } = entriesForVariant;
 
-    log.debug(`Importing variant entries for: ${content_type}/${locale}/${entry_uid}`, this.config.context);
+    log.info(`Importing variant entries for: ${content_type}/${locale}/${entry_uid}`, this.config.context);
 
     const ctConfig = this.config.modules['content-types'];
     const contentType: ContentTypeStruct = JSON.parse(
@@ -195,6 +270,29 @@ export default class VariantEntries extends VariantAdapter<VariantHttpClient<Imp
       try {
         const variantEntries = (await fs.readChunkFiles.next()) as VariantEntryStruct[];
         if (variantEntries?.length) {
+          totalVariantEntries = totalVariantEntries + variantEntries.length;
+          
+          // Initialize progress ONLY when we find the first variants (lazy initialization)
+          if (!this.processInitialized && this.progress) {
+            const processName = this.parentProgressManager ? 'Variant Entries' : PROCESS_NAMES.VARIANT_ENTRIES;
+            
+            if (this.parentProgressManager) {
+              // Update the existing process total instead of creating a new one
+              this.progress.updateProcessTotal(processName, variantEntries.length);
+            } else {
+              this.progress.addProcess(PROCESS_NAMES.VARIANT_ENTRIES, variantEntries.length);
+              this.progress.startProcess(PROCESS_NAMES.VARIANT_ENTRIES);
+            }
+            this.processInitialized = true;
+            log.debug(`Initialized variant entries progress with first batch of ${variantEntries.length} variants`, this.config.context);
+          }
+
+          if (this.processInitialized && this.progress) {
+            const processName = this.parentProgressManager ? 'Variant Entries' : PROCESS_NAMES.VARIANT_ENTRIES;
+            this.progress.updateProcessTotal(processName, totalVariantEntries);
+            log.debug(`Updated progress total to: ${totalVariantEntries}`, this.config.context);
+          }
+
           log.debug(`Processing batch of ${variantEntries.length} variant entries`, this.config.context);
           await this.handleConcurrency(contentType, variantEntries, entriesForVariant);
         }
@@ -234,7 +332,7 @@ export default class VariantEntries extends VariantAdapter<VariantHttpClient<Imp
     const batches = chunk(variantEntries, variantEntryConfig.apiConcurrency || 5);
     if (isEmpty(batches)) return;
 
-    log.debug(`Starting concurrent processing for ${variantEntries.length} variant entries`, this.config.context);
+    log.debug(`Starting concurrent processing for ${variantEntries?.length} variant entries`, this.config.context);
 
     for (const [, batch] of entries(batches)) {
       batchNo += 1;
@@ -242,7 +340,7 @@ export default class VariantEntries extends VariantAdapter<VariantHttpClient<Imp
       const start = Date.now();
 
       log.debug(
-        `Processing batch ${batchNo}/${batches.length} with ${batch.length} variant entries`,
+        `Processing batch ${batchNo}/${batches?.length} with ${batch?.length} variant entries`,
         this.config.context,
       );
 
@@ -252,6 +350,13 @@ export default class VariantEntries extends VariantAdapter<VariantHttpClient<Imp
             `Created entry variant: '${variantUid}' of entry uid ${entryUid} locale '${locale}'`,
             this.config.context,
           );
+          const processName = this.parentProgressManager ? 'Variant Entries' : PROCESS_NAMES.VARIANT_ENTRIES;
+          this.updateProgress(
+            true,
+            `variant entry: '${variantUid}' of entry uid ${entryUid} locale '${locale}'`,
+            undefined,
+            processName,
+          );
         };
 
         const onReject = ({ error, apiData }: any) => {
@@ -262,6 +367,14 @@ export default class VariantEntries extends VariantAdapter<VariantHttpClient<Imp
             this.config.context,
             `Failed to create entry variant: '${variantUid}' of entry uid ${entryUid} locale '${locale}'`,
           );
+          const processName = this.parentProgressManager ? 'Variant Entries' : PROCESS_NAMES.VARIANT_ENTRIES;
+          this.updateProgress(
+            false,
+            `'${variantUid}' of entry uid ${entryUid} locale '${locale}'`,
+            (error as any)?.message ||
+              `Failed to create entry variant: '${variantUid}' of entry uid ${entryUid} locale '${locale}'`,
+            processName,
+          );
         };
         // NOTE Find new variant Id by old Id
         const variantId = this.variantIdList[variantEntry._variant._uid] as string;
@@ -302,7 +415,7 @@ export default class VariantEntries extends VariantAdapter<VariantHttpClient<Imp
       }
 
       // NOTE Handle the API response here
-      log.debug(`Waiting for ${allPromise.length} variant entry creation promises to complete`, this.config.context);
+      log.debug(`Waiting for ${allPromise.length} variant entry creation promises to complete`, this.config.context);     
       await Promise.allSettled(allPromise);
       log.debug(`Batch ${batchNo} creation completed`, this.config.context);
 
@@ -455,7 +568,7 @@ export default class VariantEntries extends VariantAdapter<VariantHttpClient<Imp
         ?.filter((ref: any) => ref._content_type_uid === 'sys_assets')
         .map((ref: any) => ref.path) || [];
 
-    log.debug(`Found ${pathsToUpdate.length} file field paths to update`, this.config.context);
+    log.debug(`Found ${pathsToUpdate?.length} file field paths to update`, this.config.context);
     pathsToUpdate.forEach((path: string) => setValue(variantEntry, path.split('.')));
   }
 
@@ -485,12 +598,12 @@ export default class VariantEntries extends VariantAdapter<VariantHttpClient<Imp
       }
 
       if (this.failedVariantEntries.has(variantEntryUID)) {
-        log.debug(`Variant UID not found. Skipping entry variant publish for ${variantEntryUID}`, this.config.context);
+        log.info(`Variant UID not found. Skipping entry variant publish for ${variantEntryUID}`, this.config.context);
         continue;
       }
 
       if (this.environments?.length) {
-        log.debug('No environment found! Skipping entry variant publishing...', this.config.context);
+        log.info('No environment found! Skipping entry variant publishing...', this.config.context);
         return;
       }
 
@@ -510,7 +623,7 @@ export default class VariantEntries extends VariantAdapter<VariantHttpClient<Imp
 
       const { environments, locales } = this.serializePublishEntries(variantEntry);
       if (environments?.length === 0 || locales?.length === 0) {
-        log.debug(`Skipping publish for variant ${newVariantUid} - no environments or locales`, this.config.context);
+        log.info(`Skipping publish for variant ${newVariantUid} - no environments or locales`, this.config.context);
         continue;
       }
 

package/src/index.ts

@@ -2,4 +2,5 @@ export * from './types';
 export * from './utils';
 export * from './export';
 export * from './import';
-export * from './messages'
+export * from './messages';
+export * from './utils/constants';

package/src/types/export-config.ts

@@ -33,7 +33,6 @@ export type masterLocale = {
 
 export interface DefaultConfig {
   context: Context;
-  contentVersion: number;
   versioning: boolean;
   host: string;
   cdn?: string;
@@ -233,7 +232,6 @@ export interface DefaultConfig {
   writeConcurrency: number;
   developerHubBaseUrl: string;
   marketplaceAppEncryptionKey: string;
-  onlyTSModules: string[];
 }
 
 export interface ExportConfig extends DefaultConfig {

package/src/types/import-config.ts

@@ -79,7 +79,6 @@ export interface ImportConfig extends ImportDefaultConfig, AnyProperty {
   authtoken?: string;
   destinationStackName?: string;
   org_uid?: string;
-  contentVersion: number;
   replaceExisting?: boolean;
   skipExisting?: boolean;
   stackName?: string;

package/src/types/utils.ts

@@ -11,7 +11,7 @@ export interface Context {
   command: string;
   module: string;
   userId: string | undefined;
-  email: string | undefined;
+  email?: string | undefined;
   sessionId: string | undefined;
   clientId?: string | undefined;
   apiKey: string;