@contentstack/cli-variants 1.3.3 → 2.0.0-beta.1

package/lib/import/project.js

@@ -13,6 +13,7 @@ const path_1 = require("path");
 const fs_1 = require("fs");
 const cli_utilities_1 = require("@contentstack/cli-utilities");
 const utils_1 = require("../utils");
+const constants_1 = require("../utils/constants");
 class Project extends utils_1.PersonalizationAdapter {
     constructor(config) {
         const conf = {
@@ -23,7 +24,8 @@ class Project extends utils_1.PersonalizationAdapter {
         super(Object.assign(config, conf));
         this.config = config;
         this.projectMapperFolderPath = (0, path_1.resolve)((0, cli_utilities_1.sanitizePath)(this.config.backupDir), 'mapper', (0, cli_utilities_1.sanitizePath)(this.config.modules.personalize.dirName), 'projects');
-        this.config.context.module = 'project';
+        this.config.context.module = constants_1.MODULE_CONTEXTS.PROJECTS;
+        this.projectsData = [];
     }
     /**
      * The function asynchronously imports projects data from a file and creates projects based on the
@@ -31,20 +33,32 @@ class Project extends utils_1.PersonalizationAdapter {
      */
     import() {
         return __awaiter(this, void 0, void 0, function* () {
-            const personalize = this.config.modules.personalize;
-            const { dirName, fileName } = personalize.projects;
-            const projectPath = (0, path_1.join)((0, cli_utilities_1.sanitizePath)(this.config.data), (0, cli_utilities_1.sanitizePath)(personalize.dirName), (0, cli_utilities_1.sanitizePath)(dirName), (0, cli_utilities_1.sanitizePath)(fileName));
-            cli_utilities_1.log.debug(`Checking for project file: ${projectPath}`, this.config.context);
-            if ((0, fs_1.existsSync)(projectPath)) {
-                const projects = JSON.parse((0, fs_1.readFileSync)(projectPath, 'utf8'));
-                cli_utilities_1.log.debug(`Loaded ${(projects === null || projects === void 0 ? void 0 : projects.length) || 0} projects from file`, this.config.context);
-                if (!projects || projects.length < 1) {
-                    this.config.modules.personalize.importData = false; // Stop personalize import if stack not connected to any project
-                    cli_utilities_1.log.warn('No projects found in file', this.config.context);
+            try {
+                cli_utilities_1.log.debug('Starting personalize project import...', this.config.context);
+                const [canImport, projectsCount] = yield this.analyzeProjects();
+                if (!canImport) {
+                    cli_utilities_1.log.info('No projects found to import', this.config.context);
+                    if (this.parentProgressManager) {
+                        this.parentProgressManager.tick(true, 'projects module (no data)', null, constants_1.PROCESS_NAMES.PROJECTS);
+                    }
                     return;
                 }
+                // Fix 1: Always use parent progress manager when available
+                let progress;
+                if (this.parentProgressManager) {
+                    progress = this.parentProgressManager;
+                    cli_utilities_1.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(constants_1.PROCESS_NAMES.PROJECTS, projectsCount);
+                    cli_utilities_1.log.debug('Created standalone progress manager for projects import', this.config.context);
+                }
                 yield this.init();
-                for (const project of projects) {
+                for (const project of this.projectsData) {
+                    if (!this.parentProgressManager) {
+                        progress.updateStatus(constants_1.IMPORT_PROCESS_STATUS[constants_1.PROCESS_NAMES.PROJECTS].CREATING);
+                    }
                     cli_utilities_1.log.debug(`Processing project: ${project.name}`, this.config.context);
                     const createProject = (newName) => __awaiter(this, void 0, void 0, function* () {
                         cli_utilities_1.log.debug(`Creating project with name: ${newName || project.name}`, this.config.context);
@@ -56,26 +70,71 @@ class Project extends utils_1.PersonalizationAdapter {
                             if (error.includes('personalization.PROJECTS.DUPLICATE_NAME') ||
                                 error.includes('personalize.PROJECTS.DUPLICATE_NAME')) {
                                 cli_utilities_1.log.warn(`Project name already exists, generating new name`, this.config.context);
+                                // Prevent progress bar corruption with clean newlines
+                                cli_utilities_1.cliux.print('\n');
                                 const projectName = yield (0, utils_1.askProjectName)('Copy Of ' + (newName || project.name));
+                                cli_utilities_1.cliux.print('\n');
+                                if (this.parentProgressManager) {
+                                    this.parentProgressManager.updateStatus(constants_1.IMPORT_PROCESS_STATUS[constants_1.PROCESS_NAMES.PROJECTS].CREATING, constants_1.PROCESS_NAMES.PROJECTS);
+                                }
                                 return yield createProject(projectName);
                             }
                             throw error;
                         }));
                     });
-                    const projectRes = yield createProject(this.config.personalizeProjectName);
-                    this.config.modules.personalize.project_id = projectRes.uid;
-                    this.config.modules.personalize.importData = true;
-                    yield utils_1.fsUtil.makeDirectory(this.projectMapperFolderPath);
-                    utils_1.fsUtil.writeFile((0, path_1.resolve)((0, cli_utilities_1.sanitizePath)(this.projectMapperFolderPath), 'projects.json'), projectRes);
-                    cli_utilities_1.log.success(`Project created successfully: ${projectRes.uid}`, this.config.context);
-                    cli_utilities_1.log.debug(`Project data saved to: ${this.projectMapperFolderPath}/projects.json`, this.config.context);
+                    try {
+                        const projectRes = yield createProject(this.config.personalizeProjectName);
+                        this.config.modules.personalize.project_id = projectRes.uid;
+                        this.config.modules.personalize.importData = true;
+                        yield utils_1.fsUtil.makeDirectory(this.projectMapperFolderPath);
+                        utils_1.fsUtil.writeFile((0, path_1.resolve)((0, cli_utilities_1.sanitizePath)(this.projectMapperFolderPath), 'projects.json'), projectRes);
+                        this.updateProgress(true, `project: ${project.name}`, undefined, constants_1.PROCESS_NAMES.PROJECTS);
+                        cli_utilities_1.log.success(`Project created successfully: ${projectRes.uid}`, this.config.context);
+                    }
+                    catch (error) {
+                        this.updateProgress(false, `project: ${project.name}`, error === null || error === void 0 ? void 0 : error.message, constants_1.PROCESS_NAMES.PROJECTS);
+                        throw error;
+                    }
                 }
+                // Only complete progress if we own the progress manager (no parent)
+                if (!this.parentProgressManager) {
+                    this.completeProgress(true);
+                }
+                cli_utilities_1.log.success(`Projects imported successfully! Total projects: ${projectsCount} - personalization enabled`, this.config.context);
             }
-            else {
-                this.config.modules.personalize.importData = false; // Stop personalize import if stack not connected to any project
-                cli_utilities_1.log.warn(`Project file not found: ${projectPath}`, this.config.context);
+            catch (error) {
+                this.config.modules.personalize.importData = false;
+                if (!this.parentProgressManager) {
+                    this.completeProgress(false, (error === null || error === void 0 ? void 0 : error.message) || 'Project import failed');
+                }
+                throw error;
             }
         });
     }
+    analyzeProjects() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.withLoadingSpinner('PROJECT: Analyzing import data...', () => __awaiter(this, void 0, void 0, function* () {
+                var _a;
+                const personalize = this.config.modules.personalize;
+                const { dirName, fileName } = personalize.projects;
+                const projectPath = (0, path_1.join)((0, cli_utilities_1.sanitizePath)(this.config.data), (0, cli_utilities_1.sanitizePath)(personalize.dirName), (0, cli_utilities_1.sanitizePath)(dirName), (0, cli_utilities_1.sanitizePath)(fileName));
+                cli_utilities_1.log.debug(`Checking for project file: ${projectPath}`, this.config.context);
+                if (!(0, fs_1.existsSync)(projectPath)) {
+                    this.config.modules.personalize.importData = false;
+                    cli_utilities_1.log.warn(`Project file not found: ${projectPath}`, this.config.context);
+                    return [false, 0];
+                }
+                this.projectsData = JSON.parse((0, fs_1.readFileSync)(projectPath, 'utf8'));
+                const projectsCount = ((_a = this.projectsData) === null || _a === void 0 ? void 0 : _a.length) || 0;
+                if (projectsCount < 1) {
+                    this.config.modules.personalize.importData = false;
+                    cli_utilities_1.log.warn('No projects found in file', this.config.context);
+                    return [false, 0];
+                }
+                cli_utilities_1.log.debug(`Found ${projectsCount} projects to import`, this.config.context);
+                return [true, projectsCount];
+            }));
+        });
+    }
 }
 exports.default = Project;

package/lib/import/variant-entries.d.ts

@@ -17,9 +17,19 @@ export default class VariantEntries extends VariantAdapter<VariantHttpClient<Imp
     private failedVariantPath;
     private failedVariantEntries;
     private environments;
+    progress: any;
+    private processInitialized;
     constructor(config: ImportConfig & {
         helpers?: ImportHelperMethodsConfig;
     });
+    /**
+     * Set parent progress manager for integration with entries module
+     */
+    setParentProgressManager(parentProgress: any): void;
+    /**
+     * Update progress for a specific item
+     */
+    protected updateProgress(success: boolean, itemName: string, error?: string, processName?: string): void;
     /**
      * This TypeScript function asynchronously imports backupDir from a JSON file and processes the entries
      * for variant entries.

package/lib/import/variant-entries.js

@@ -56,6 +56,7 @@ const fs_1 = require("fs");
 const cli_utilities_1 = require("@contentstack/cli-utilities");
 const variant_api_adapter_1 = __importStar(require("../utils/variant-api-adapter"));
 const utils_1 = require("../utils");
+const constants_1 = require("../utils/constants");
 class VariantEntries extends variant_api_adapter_1.default {
     constructor(config) {
         const conf = {
@@ -72,13 +73,29 @@ class VariantEntries extends variant_api_adapter_1.default {
         };
         super(Object.assign((0, omit_1.default)(config, ['helpers']), conf));
         this.config = config;
+        this.processInitialized = false;
         this.entriesMapperPath = (0, path_1.resolve)((0, cli_utilities_1.sanitizePath)(config.backupDir), 'mapper', 'entries');
         this.personalizeConfig = this.config.modules.personalize;
         this.entriesDirPath = (0, path_1.resolve)((0, cli_utilities_1.sanitizePath)(config.backupDir), (0, cli_utilities_1.sanitizePath)(config.modules.entries.dirName));
         this.failedVariantPath = (0, path_1.resolve)((0, cli_utilities_1.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 = constants_1.MODULE_CONTEXTS.VARIANT_ENTRIES;
+        }
+    }
+    /**
+     * Set parent progress manager for integration with entries module
+     */
+    setParentProgressManager(parentProgress) {
+        this.parentProgressManager = parentProgress;
+        this.progress = parentProgress;
+    }
+    /**
+     * Update progress for a specific item
+     */
+    updateProgress(success, itemName, error, processName) {
+        if (this.progress) {
+            this.progress.tick(success, itemName, error, processName);
         }
     }
     /**
@@ -92,53 +109,95 @@ class VariantEntries extends variant_api_adapter_1.default {
     import() {
         return __awaiter(this, void 0, void 0, function* () {
             var _a, _b, _c;
-            const filePath = (0, path_1.resolve)((0, cli_utilities_1.sanitizePath)(this.entriesMapperPath), 'data-for-variant-entry.json');
-            const variantIdPath = (0, path_1.resolve)((0, cli_utilities_1.sanitizePath)(this.config.backupDir), 'mapper', (0, cli_utilities_1.sanitizePath)(this.personalizeConfig.dirName), (0, cli_utilities_1.sanitizePath)(this.personalizeConfig.experiences.dirName), 'variants-uid-mapping.json');
-            cli_utilities_1.log.debug(`Checking for variant entry data file: ${filePath}`, this.config.context);
-            if (!(0, fs_1.existsSync)(filePath)) {
-                cli_utilities_1.log.warn(`Variant entry data file not found at path: ${filePath}, skipping import`, this.config.context);
-                return;
-            }
-            cli_utilities_1.log.debug(`Checking for variant ID mapping file: ${variantIdPath}`, this.config.context);
-            if (!(0, fs_1.existsSync)(variantIdPath)) {
-                cli_utilities_1.log.error('Variant UID mapping file not found', this.config.context);
-                return;
-            }
-            const entriesForVariants = utils_1.fsUtil.readFile(filePath, true);
-            cli_utilities_1.log.debug(`Loaded ${(entriesForVariants === null || entriesForVariants === void 0 ? void 0 : entriesForVariants.length) || 0} entries for variant processing`, this.config.context);
-            if ((0, isEmpty_1.default)(entriesForVariants)) {
-                cli_utilities_1.log.warn('No entries found for variant import', this.config.context);
-                return;
-            }
-            const entriesUidMapperPath = (0, path_1.join)((0, cli_utilities_1.sanitizePath)(this.entriesMapperPath), 'uid-mapping.json');
-            const assetUidMapperPath = (0, path_1.resolve)((0, cli_utilities_1.sanitizePath)(this.config.backupDir), 'mapper', 'assets', 'uid-mapping.json');
-            const assetUrlMapperPath = (0, path_1.resolve)((0, cli_utilities_1.sanitizePath)(this.config.backupDir), 'mapper', 'assets', 'url-mapping.json');
-            const taxonomiesPath = (0, path_1.resolve)((0, cli_utilities_1.sanitizePath)(this.config.backupDir), 'mapper', (0, cli_utilities_1.sanitizePath)(this.config.modules.taxonomies.dirName), 'terms', 'success.json');
-            const marketplaceAppMapperPath = (0, path_1.resolve)((0, cli_utilities_1.sanitizePath)(this.config.backupDir), 'mapper', 'marketplace_apps', 'uid-mapping.json');
-            const envPath = (0, path_1.resolve)((0, cli_utilities_1.sanitizePath)(this.config.backupDir), 'environments', 'environments.json');
-            cli_utilities_1.log.debug('Loading variant ID mapping and dependency data', this.config.context);
-            // NOTE Read and store list of variant IDs
-            this.variantIdList = (utils_1.fsUtil.readFile(variantIdPath, true) || {});
-            if ((0, isEmpty_1.default)(this.variantIdList)) {
-                cli_utilities_1.log.warn('Empty variant UID data found', this.config.context);
-                return;
+            try {
+                const filePath = (0, path_1.resolve)((0, cli_utilities_1.sanitizePath)(this.entriesMapperPath), 'data-for-variant-entry.json');
+                const variantIdPath = (0, path_1.resolve)((0, cli_utilities_1.sanitizePath)(this.config.backupDir), 'mapper', (0, cli_utilities_1.sanitizePath)(this.personalizeConfig.dirName), (0, cli_utilities_1.sanitizePath)(this.personalizeConfig.experiences.dirName), 'variants-uid-mapping.json');
+                cli_utilities_1.log.debug(`Checking for variant entry data file: ${filePath}`, this.config.context);
+                if (!(0, fs_1.existsSync)(filePath)) {
+                    cli_utilities_1.log.warn(`Variant entry data file not found at path: ${filePath}, skipping import`, this.config.context);
+                    return;
+                }
+                cli_utilities_1.log.debug(`Checking for variant ID mapping file: ${variantIdPath}`, this.config.context);
+                if (!(0, fs_1.existsSync)(variantIdPath)) {
+                    cli_utilities_1.log.error('Variant UID mapping file not found', this.config.context);
+                    return;
+                }
+                const entriesForVariants = utils_1.fsUtil.readFile(filePath, true);
+                cli_utilities_1.log.debug(`Loaded ${(entriesForVariants === null || entriesForVariants === void 0 ? void 0 : entriesForVariants.length) || 0} entries for variant processing`, this.config.context);
+                if ((0, isEmpty_1.default)(entriesForVariants)) {
+                    cli_utilities_1.log.warn('No entries found for variant import', this.config.context);
+                    return;
+                }
+                const entriesUidMapperPath = (0, path_1.join)((0, cli_utilities_1.sanitizePath)(this.entriesMapperPath), 'uid-mapping.json');
+                const assetUidMapperPath = (0, path_1.resolve)((0, cli_utilities_1.sanitizePath)(this.config.backupDir), 'mapper', 'assets', 'uid-mapping.json');
+                const assetUrlMapperPath = (0, path_1.resolve)((0, cli_utilities_1.sanitizePath)(this.config.backupDir), 'mapper', 'assets', 'url-mapping.json');
+                const taxonomiesPath = (0, path_1.resolve)((0, cli_utilities_1.sanitizePath)(this.config.backupDir), 'mapper', (0, cli_utilities_1.sanitizePath)(this.config.modules.taxonomies.dirName), 'terms', 'success.json');
+                const marketplaceAppMapperPath = (0, path_1.resolve)((0, cli_utilities_1.sanitizePath)(this.config.backupDir), 'mapper', 'marketplace_apps', 'uid-mapping.json');
+                const envPath = (0, path_1.resolve)((0, cli_utilities_1.sanitizePath)(this.config.backupDir), 'environments', 'environments.json');
+                cli_utilities_1.log.debug('Loading variant ID mapping and dependency data', this.config.context);
+                // NOTE Read and store list of variant IDs
+                this.variantIdList = (utils_1.fsUtil.readFile(variantIdPath, true) || {});
+                if ((0, isEmpty_1.default)(this.variantIdList)) {
+                    cli_utilities_1.log.warn('Empty variant UID data found', this.config.context);
+                    return;
+                }
+                // NOTE entry relational data lookup dependencies.
+                this.entriesUidMapper = (utils_1.fsUtil.readFile(entriesUidMapperPath, true) || {});
+                this.installedExtensions = (utils_1.fsUtil.readFile(marketplaceAppMapperPath) || { extension_uid: {} })
+                    .extension_uid;
+                this.taxonomies = (utils_1.fsUtil.readFile(taxonomiesPath, true) || {});
+                this.assetUidMapper = (utils_1.fsUtil.readFile(assetUidMapperPath, true) || {});
+                this.assetUrlMapper = (utils_1.fsUtil.readFile(assetUrlMapperPath, true) || {});
+                this.environments = (utils_1.fsUtil.readFile(envPath, true) || {});
+                cli_utilities_1.log.debug(`Loaded dependency data - Entries: ${(_a = Object.keys(this.entriesUidMapper)) === null || _a === void 0 ? void 0 : _a.length}, Assets: ${(_b = Object.keys(this.assetUidMapper)) === null || _b === void 0 ? void 0 : _b.length}, Taxonomies: ${(_c = Object.keys(this.taxonomies)) === null || _c === void 0 ? void 0 : _c.length}`, this.config.context);
+                // Initialize progress manager - will be set up lazily when first variants are found
+                if (this.parentProgressManager) {
+                    this.progress = this.parentProgressManager;
+                    cli_utilities_1.log.debug('Using parent progress manager for variant entries import', this.config.context);
+                }
+                else {
+                    this.progress = this.createSimpleProgress(constants_1.PROCESS_NAMES.VARIANT_ENTRIES);
+                    cli_utilities_1.log.debug('Created standalone progress manager for variant entries import', this.config.context);
+                }
+                // set the token
+                yield this.variantInstance.init();
+                cli_utilities_1.log.info(`Processing ${entriesForVariants === null || entriesForVariants === void 0 ? void 0 : entriesForVariants.length} entries for variant import`, this.config.context);
+                for (const entriesForVariant of entriesForVariants) {
+                    try {
+                        yield this.importVariantEntries(entriesForVariant);
+                        cli_utilities_1.log.debug(`Successfully processed variant entry: ${entriesForVariant.content_type}/${entriesForVariant.locale}/${entriesForVariant.entry_uid}`, this.config.context);
+                    }
+                    catch (error) {
+                        (0, cli_utilities_1.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' : constants_1.PROCESS_NAMES.VARIANT_ENTRIES;
+                    this.progress.completeProcess(processName, true);
+                    cli_utilities_1.log.success(`Completed import of variant entries across ${entriesForVariants.length} entries`, this.config.context);
+                }
+                else if (entriesForVariants.length === 0) {
+                    cli_utilities_1.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);
+                }
+                cli_utilities_1.log.success(`Variant entries imported successfully! Total entries: ${entriesForVariants.length} - processing completed`, this.config.context);
             }
-            // NOTE entry relational data lookup dependencies.
-            this.entriesUidMapper = (utils_1.fsUtil.readFile(entriesUidMapperPath, true) || {});
-            this.installedExtensions = (utils_1.fsUtil.readFile(marketplaceAppMapperPath) || { extension_uid: {} })
-                .extension_uid;
-            this.taxonomies = (utils_1.fsUtil.readFile(taxonomiesPath, true) || {});
-            this.assetUidMapper = (utils_1.fsUtil.readFile(assetUidMapperPath, true) || {});
-            this.assetUrlMapper = (utils_1.fsUtil.readFile(assetUrlMapperPath, true) || {});
-            this.environments = (utils_1.fsUtil.readFile(envPath, true) || {});
-            cli_utilities_1.log.debug(`Loaded dependency data - Entries: ${(_a = Object.keys(this.entriesUidMapper)) === null || _a === void 0 ? void 0 : _a.length}, Assets: ${(_b = Object.keys(this.assetUidMapper)) === null || _b === void 0 ? void 0 : _b.length}, Taxonomies: ${(_c = Object.keys(this.taxonomies)) === null || _c === void 0 ? void 0 : _c.length}`, this.config.context);
-            // set the token
-            yield this.variantInstance.init();
-            cli_utilities_1.log.info(`Processing ${entriesForVariants === null || entriesForVariants === void 0 ? void 0 : entriesForVariants.length} entries for variant import`, this.config.context);
-            for (const entriesForVariant of entriesForVariants) {
-                yield this.importVariantEntries(entriesForVariant);
+            catch (error) {
+                // Complete progress with error if we initialized it
+                if (this.processInitialized && this.progress) {
+                    const processName = this.parentProgressManager ? 'Variant Entries' : constants_1.PROCESS_NAMES.VARIANT_ENTRIES;
+                    this.progress.completeProcess(processName, false);
+                }
+                if (!this.parentProgressManager) {
+                    this.completeProgress(false, (error === null || error === void 0 ? void 0 : error.message) || 'Variant entries import failed');
+                }
+                (0, cli_utilities_1.handleAndLogError)(error, this.config.context, 'Variant entries import failed');
+                throw error;
             }
-            cli_utilities_1.log.success('All variant entries have been imported and published successfully', this.config.context);
         });
     }
     /**
@@ -148,6 +207,7 @@ class VariantEntries extends variant_api_adapter_1.default {
      */
     importVariantEntries(entriesForVariant) {
         return __awaiter(this, void 0, void 0, function* () {
+            let totalVariantEntries = 0;
             const variantEntry = this.config.modules.variantEntry;
             const { content_type, locale, entry_uid } = entriesForVariant;
             cli_utilities_1.log.info(`Importing variant entries for: ${content_type}/${locale}/${entry_uid}`, this.config.context);
@@ -160,7 +220,27 @@ class VariantEntries extends variant_api_adapter_1.default {
                 try {
                     const variantEntries = (yield fs.readChunkFiles.next());
                     if (variantEntries === null || variantEntries === void 0 ? void 0 : variantEntries.length) {
-                        cli_utilities_1.log.info(`Processing batch of ${variantEntries.length} variant entries`, this.config.context);
+                        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' : constants_1.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(constants_1.PROCESS_NAMES.VARIANT_ENTRIES, variantEntries.length);
+                                this.progress.startProcess(constants_1.PROCESS_NAMES.VARIANT_ENTRIES);
+                            }
+                            this.processInitialized = true;
+                            cli_utilities_1.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' : constants_1.PROCESS_NAMES.VARIANT_ENTRIES;
+                            this.progress.updateProcessTotal(processName, totalVariantEntries);
+                            cli_utilities_1.log.debug(`Updated progress total to: ${totalVariantEntries}`, this.config.context);
+                        }
+                        cli_utilities_1.log.debug(`Processing batch of ${variantEntries.length} variant entries`, this.config.context);
                         yield this.handleConcurrency(contentType, variantEntries, entriesForVariant);
                     }
                 }
@@ -202,11 +282,16 @@ class VariantEntries extends variant_api_adapter_1.default {
                 for (let [, variantEntry] of (0, entries_1.default)(batch)) {
                     const onSuccess = ({ response, apiData: { entryUid, variantUid } }) => {
                         cli_utilities_1.log.info(`Created entry variant: '${variantUid}' of entry uid ${entryUid} locale '${locale}'`, this.config.context);
+                        const processName = this.parentProgressManager ? 'Variant Entries' : constants_1.PROCESS_NAMES.VARIANT_ENTRIES;
+                        this.updateProgress(true, `variant entry: '${variantUid}' of entry uid ${entryUid} locale '${locale}'`, undefined, processName);
                     };
                     const onReject = ({ error, apiData }) => {
                         const { entryUid, variantUid } = apiData;
                         this.failedVariantEntries.set(variantUid, apiData);
                         (0, cli_utilities_1.handleAndLogError)(error, this.config.context, `Failed to create entry variant: '${variantUid}' of entry uid ${entryUid} locale '${locale}'`);
+                        const processName = this.parentProgressManager ? 'Variant Entries' : constants_1.PROCESS_NAMES.VARIANT_ENTRIES;
+                        this.updateProgress(false, `'${variantUid}' of entry uid ${entryUid} locale '${locale}'`, (error === null || error === void 0 ? void 0 : error.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];

package/lib/index.d.ts

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

package/lib/index.js

@@ -19,3 +19,4 @@ __exportStar(require("./utils"), exports);
 __exportStar(require("./export"), exports);
 __exportStar(require("./import"), exports);
 __exportStar(require("./messages"), exports);
+__exportStar(require("./utils/constants"), exports);

package/lib/types/export-config.d.ts

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

package/lib/types/import-config.d.ts

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

package/lib/types/utils.d.ts

@@ -9,7 +9,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;

package/lib/utils/constants.d.ts

@@ -0,0 +1,91 @@
+export declare const PROCESS_NAMES: {
+    readonly PROJECTS: "Projects";
+    readonly ATTRIBUTES: "Attributes";
+    readonly AUDIENCES: "Audiences";
+    readonly EVENTS: "Events";
+    readonly EXPERIENCES: "Experiences";
+    readonly VARIANT_ENTRIES: "Variant Entries";
+};
+export declare const MODULE_DISPLAY_MAPPER: {
+    readonly events: "Events";
+    readonly attributes: "Attributes";
+    readonly audiences: "Audiences";
+    readonly experiences: "Experiences";
+    readonly projects: "Projects";
+    readonly 'variant-entries': "Variant Entries";
+};
+export declare const MODULE_CONTEXTS: {
+    readonly PROJECTS: "projects";
+    readonly ATTRIBUTES: "attributes";
+    readonly AUDIENCES: "audiences";
+    readonly EVENTS: "events";
+    readonly EXPERIENCES: "experiences";
+    readonly VARIANT_ENTRIES: "variant-entries";
+};
+export declare const EXPORT_PROCESS_STATUS: {
+    readonly Projects: {
+        readonly FETCHING: "Fetching projects...";
+        readonly EXPORTING: "Exporting projects...";
+        readonly FAILED: "Failed to export projects.";
+    };
+    readonly Attributes: {
+        readonly FETCHING: "Fetching attributes...";
+        readonly EXPORTING: "Exporting attributes...";
+        readonly FAILED: "Failed to export attributes.";
+    };
+    readonly Audiences: {
+        readonly FETCHING: "Fetching audiences...";
+        readonly EXPORTING: "Exporting audiences...";
+        readonly FAILED: "Failed to export audiences.";
+    };
+    readonly Events: {
+        readonly FETCHING: "Fetching events...";
+        readonly EXPORTING: "Exporting events...";
+        readonly FAILED: "Failed to export events.";
+    };
+    readonly Experiences: {
+        readonly FETCHING: "Fetching experiences...";
+        readonly EXPORTING: "Exporting experiences...";
+        readonly FAILED: "Failed to export experiences.";
+    };
+    readonly "Variant Entries": {
+        readonly PROCESSING: "Processing variant entries...";
+        readonly EXPORTING: "Exporting variant entries...";
+        readonly FAILED: "Failed to export variant entries.";
+    };
+};
+export declare const IMPORT_PROCESS_STATUS: {
+    readonly Projects: {
+        readonly CREATING: "Creating projects...";
+        readonly IMPORTING: "Importing projects...";
+        readonly FAILED: "Failed to import projects.";
+    };
+    readonly Attributes: {
+        readonly CREATING: "Creating attributes...";
+        readonly IMPORTING: "Importing attributes...";
+        readonly FAILED: "Failed to import attributes.";
+    };
+    readonly Audiences: {
+        readonly CREATING: "Creating audiences...";
+        readonly IMPORTING: "Importing audiences...";
+        readonly FAILED: "Failed to import audiences.";
+    };
+    readonly Events: {
+        readonly CREATING: "Creating events...";
+        readonly IMPORTING: "Importing events...";
+        readonly FAILED: "Failed to import events.";
+    };
+    readonly Experiences: {
+        readonly CREATING: "Creating experiences...";
+        readonly IMPORTING: "Importing experiences...";
+        readonly FAILED: "Failed to import experiences.";
+    };
+    readonly "Variant Entries": {
+        readonly PROCESSING: "Processing variant entries...";
+        readonly IMPORTING: "Importing variant entries...";
+        readonly FAILED: "Failed to import variant entries.";
+    };
+};
+export type ProcessName = typeof PROCESS_NAMES[keyof typeof PROCESS_NAMES];
+export type ModuleKey = keyof typeof MODULE_DISPLAY_MAPPER;
+export type ModuleContext = typeof MODULE_CONTEXTS[keyof typeof MODULE_CONTEXTS];

package/lib/utils/constants.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IMPORT_PROCESS_STATUS = exports.EXPORT_PROCESS_STATUS = exports.MODULE_CONTEXTS = exports.MODULE_DISPLAY_MAPPER = exports.PROCESS_NAMES = void 0;
+exports.PROCESS_NAMES = {
+    PROJECTS: 'Projects',
+    ATTRIBUTES: 'Attributes',
+    AUDIENCES: 'Audiences',
+    EVENTS: 'Events',
+    EXPERIENCES: 'Experiences',
+    VARIANT_ENTRIES: 'Variant Entries',
+};
+exports.MODULE_DISPLAY_MAPPER = {
+    events: exports.PROCESS_NAMES.EVENTS,
+    attributes: exports.PROCESS_NAMES.ATTRIBUTES,
+    audiences: exports.PROCESS_NAMES.AUDIENCES,
+    experiences: exports.PROCESS_NAMES.EXPERIENCES,
+    projects: exports.PROCESS_NAMES.PROJECTS,
+    'variant-entries': exports.PROCESS_NAMES.VARIANT_ENTRIES,
+};
+exports.MODULE_CONTEXTS = {
+    PROJECTS: 'projects',
+    ATTRIBUTES: 'attributes',
+    AUDIENCES: 'audiences',
+    EVENTS: 'events',
+    EXPERIENCES: 'experiences',
+    VARIANT_ENTRIES: 'variant-entries',
+};
+// Export process status messages
+exports.EXPORT_PROCESS_STATUS = {
+    [exports.PROCESS_NAMES.PROJECTS]: {
+        FETCHING: 'Fetching projects...',
+        EXPORTING: 'Exporting projects...',
+        FAILED: 'Failed to export projects.',
+    },
+    [exports.PROCESS_NAMES.ATTRIBUTES]: {
+        FETCHING: 'Fetching attributes...',
+        EXPORTING: 'Exporting attributes...',
+        FAILED: 'Failed to export attributes.',
+    },
+    [exports.PROCESS_NAMES.AUDIENCES]: {
+        FETCHING: 'Fetching audiences...',
+        EXPORTING: 'Exporting audiences...',
+        FAILED: 'Failed to export audiences.',
+    },
+    [exports.PROCESS_NAMES.EVENTS]: {
+        FETCHING: 'Fetching events...',
+        EXPORTING: 'Exporting events...',
+        FAILED: 'Failed to export events.',
+    },
+    [exports.PROCESS_NAMES.EXPERIENCES]: {
+        FETCHING: 'Fetching experiences...',
+        EXPORTING: 'Exporting experiences...',
+        FAILED: 'Failed to export experiences.',
+    },
+    [exports.PROCESS_NAMES.VARIANT_ENTRIES]: {
+        PROCESSING: 'Processing variant entries...',
+        EXPORTING: 'Exporting variant entries...',
+        FAILED: 'Failed to export variant entries.',
+    },
+};
+// Import process status messages
+exports.IMPORT_PROCESS_STATUS = {
+    [exports.PROCESS_NAMES.PROJECTS]: {
+        CREATING: 'Creating projects...',
+        IMPORTING: 'Importing projects...',
+        FAILED: 'Failed to import projects.',
+    },
+    [exports.PROCESS_NAMES.ATTRIBUTES]: {
+        CREATING: 'Creating attributes...',
+        IMPORTING: 'Importing attributes...',
+        FAILED: 'Failed to import attributes.',
+    },
+    [exports.PROCESS_NAMES.AUDIENCES]: {
+        CREATING: 'Creating audiences...',
+        IMPORTING: 'Importing audiences...',
+        FAILED: 'Failed to import audiences.',
+    },
+    [exports.PROCESS_NAMES.EVENTS]: {
+        CREATING: 'Creating events...',
+        IMPORTING: 'Importing events...',
+        FAILED: 'Failed to import events.',
+    },
+    [exports.PROCESS_NAMES.EXPERIENCES]: {
+        CREATING: 'Creating experiences...',
+        IMPORTING: 'Importing experiences...',
+        FAILED: 'Failed to import experiences.',
+    },
+    [exports.PROCESS_NAMES.VARIANT_ENTRIES]: {
+        PROCESSING: 'Processing variant entries...',
+        IMPORTING: 'Importing variant entries...',
+        FAILED: 'Failed to import variant entries.',
+    },
+};