@contentstack/cli-cm-import 1.28.1 → 2.0.0-beta

package/lib/import/modules/variant-entries.js

@@ -2,58 +2,99 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
 const path_1 = tslib_1.__importDefault(require("path"));
-const cli_variants_1 = require("@contentstack/cli-variants");
 const cli_utilities_1 = require("@contentstack/cli-utilities");
+const cli_variants_1 = require("@contentstack/cli-variants");
 const utils_1 = require("../../utils");
-class ImportVarientEntries {
-    constructor({ importConfig }) {
+const base_class_1 = tslib_1.__importDefault(require("./base-class"));
+class ImportVariantEntries extends base_class_1.default {
+    constructor({ importConfig, stackAPIClient }) {
+        super({ importConfig, stackAPIClient });
         this.config = importConfig;
-        this.config.context.module = 'variant-entries';
+        this.config.context.module = utils_1.MODULE_CONTEXTS.VARIANT_ENTRIES;
+        this.currentModuleName = utils_1.MODULE_NAMES[utils_1.MODULE_CONTEXTS.VARIANT_ENTRIES];
         this.personalize = importConfig.modules.personalize;
         this.projectMapperFilePath = path_1.default.resolve((0, cli_utilities_1.sanitizePath)(this.config.data), 'mapper', (0, cli_utilities_1.sanitizePath)(this.personalize.dirName), 'projects', 'projects.json');
     }
     /**
-     * The `start` function in TypeScript is an asynchronous method that conditionally imports data using
-     * helper methods and logs any errors encountered.
+     * @method start
+     * @returns {Promise<void>} Promise<void>
      */
     async start() {
         try {
+            cli_utilities_1.log.debug('Starting variant entries import process...', this.config.context);
+            const [hasProject] = await this.analyzeVariantEntries();
+            if (!hasProject) {
+                cli_utilities_1.log.info('No variant entries found to import', this.config.context);
+                return;
+            }
+            const progress = this.createNestedProgress(this.currentModuleName);
+            // Add the variant entries process that will be managed by the actual VariantEntries class
+            progress.addProcess(utils_1.PROCESS_NAMES.VARIANT_ENTRIES_IMPORT, 0); // Start with 0, will be updated dynamically
+            progress.startProcess(utils_1.PROCESS_NAMES.VARIANT_ENTRIES_IMPORT);
+            progress.updateStatus(utils_1.PROCESS_STATUS[utils_1.PROCESS_NAMES.VARIANT_ENTRIES_IMPORT].IMPORTING, utils_1.PROCESS_NAMES.VARIANT_ENTRIES_IMPORT);
+            cli_utilities_1.log.info('Starting variant entries import process', this.config.context);
+            await this.importVariantEntries();
+            this.completeProgress(true);
+            cli_utilities_1.log.success('Variant entries imported successfully', this.config.context);
+        }
+        catch (error) {
+            this.completeProgress(false, (error === null || error === void 0 ? void 0 : error.message) || 'Variant entries import failed');
+            (0, cli_utilities_1.handleAndLogError)(error, Object.assign({}, this.config.context));
+        }
+    }
+    async importVariantEntries() {
+        var _a;
+        const project = utils_1.fsUtil.readFile(this.projectMapperFilePath);
+        cli_utilities_1.log.debug(`Project data loaded: ${JSON.stringify(project)}`, this.config.context);
+        if (project && project.uid) {
+            cli_utilities_1.log.debug(`Found personalize project: ${project.uid}`, this.config.context);
+            this.config.modules.personalize.project_id = project.uid;
+            cli_utilities_1.log.debug('Initializing helper methods for variant entries import', this.config.context);
+            const helpers = {
+                lookUpTerms: utils_1.lookUpTerms,
+                lookupAssets: utils_1.lookupAssets,
+                lookupEntries: utils_1.lookupEntries,
+                lookupExtension: utils_1.lookupExtension,
+                restoreJsonRteEntryRefs: utils_1.restoreJsonRteEntryRefs,
+            };
+            cli_utilities_1.log.debug('Helper methods initialized successfully', this.config.context);
+            const helperTypes = Object.keys(helpers || {}).join(', ');
+            cli_utilities_1.log.debug(`Helper method types available: ${helperTypes}`, this.config.context);
+            cli_utilities_1.log.debug('Creating VariantEntries instance', this.config.context);
+            const variantEntriesImporter = new cli_variants_1.Import.VariantEntries(Object.assign(this.config, { helpers }));
+            variantEntriesImporter.setParentProgressManager(this.progressManager);
+            cli_utilities_1.log.debug('Starting variant entries import', this.config.context);
+            await variantEntriesImporter.import();
+            // this.progressManager?.tick(true, 'variant entries import completed', null, PROCESS_NAMES.VARIANT_ENTRIES_IMPORT);
+            cli_utilities_1.log.debug('Variant entries import completed successfully', this.config.context);
+        }
+        else {
+            cli_utilities_1.log.debug('No valid project found in mapper file', this.config.context);
+            (_a = this.progressManager) === null || _a === void 0 ? void 0 : _a.tick(false, 'variant entries import', 'No personalize project linked', utils_1.PROCESS_NAMES.VARIANT_ENTRIES_IMPORT);
+            cli_utilities_1.log.info('Skipping entry variants import because no personalize project is linked.', this.config.context);
+        }
+    }
+    async analyzeVariantEntries() {
+        return this.withLoadingSpinner('VARIANT ENTRIES: Analyzing import data...', async () => {
             cli_utilities_1.log.debug(`Reading project mapper from: ${this.projectMapperFilePath}`, this.config.context);
             if (!utils_1.fileHelper.fileExistsSync(this.projectMapperFilePath)) {
                 cli_utilities_1.log.debug('Project mapper file does not exist', this.config.context);
                 cli_utilities_1.log.info('Skipping entry variants import because no personalize project mapper found.', this.config.context);
-                return;
+                return [false, 0];
             }
             const project = utils_1.fsUtil.readFile(this.projectMapperFilePath);
-            cli_utilities_1.log.debug(`Project data loaded: ${JSON.stringify(project)}`, this.config.context);
-            if (project && project.uid) {
-                cli_utilities_1.log.debug(`Found personalize project: ${project.uid}`, this.config.context);
-                this.config.modules.personalize.project_id = project.uid;
-                cli_utilities_1.log.debug('Initializing helper methods for variant entries import', this.config.context);
-                const helpers = {
-                    lookUpTerms: utils_1.lookUpTerms,
-                    lookupAssets: utils_1.lookupAssets,
-                    lookupEntries: utils_1.lookupEntries,
-                    lookupExtension: utils_1.lookupExtension,
-                    restoreJsonRteEntryRefs: utils_1.restoreJsonRteEntryRefs,
-                };
-                cli_utilities_1.log.debug('Helper methods initialized successfully', this.config.context);
-                const helperTypes = Object.keys(helpers || {}).join(', ');
-                cli_utilities_1.log.debug(`Helper method types available: ${helperTypes}`, this.config.context);
-                cli_utilities_1.log.debug('Creating VariantEntries instance', this.config.context);
-                const variantEntriesImporter = new cli_variants_1.Import.VariantEntries(Object.assign(this.config, { helpers }));
-                cli_utilities_1.log.debug('Starting variant entries import', this.config.context);
-                await variantEntriesImporter.import();
-                cli_utilities_1.log.success('Variant entries imported successfully', this.config.context);
-            }
-            else {
+            const hasValidProject = !!(project && project.uid);
+            if (!hasValidProject) {
                 cli_utilities_1.log.debug('No valid project found in mapper file', this.config.context);
-                cli_utilities_1.log.info('Skipping entry variants import because no personalize project is linked.', this.config.context);
+                return [false, 0];
             }
-        }
-        catch (error) {
-            (0, cli_utilities_1.handleAndLogError)(error, Object.assign({}, this.config.context));
-        }
+            // Basic validation - check if data file exists
+            const dataFilePath = path_1.default.resolve((0, cli_utilities_1.sanitizePath)(this.config.data), 'mapper', 'entries', 'data-for-variant-entry.json');
+            const hasVariantData = utils_1.fileHelper.fileExistsSync(dataFilePath);
+            cli_utilities_1.log.debug(`Found valid personalize project: ${project.uid} with variant data: ${hasVariantData}`, this.config.context);
+            // Return 0 count - let the variant module update it dynamically
+            return [hasValidProject && hasVariantData, 0];
+        });
     }
 }
-exports.default = ImportVarientEntries;
+exports.default = ImportVariantEntries;

package/lib/import/modules/webhooks.d.ts

@@ -24,4 +24,7 @@ export default class ImportWebhooks extends BaseClass {
      * @returns {ApiOptions} ApiOptions
      */
     serializeWebhooks(apiOptions: ApiOptions): ApiOptions;
+    private analyzeWebhooks;
+    private prepareWebhookMapper;
+    private processWebhookResults;
 }

package/lib/import/modules/webhooks.js

@@ -10,7 +10,8 @@ const base_class_1 = tslib_1.__importDefault(require("./base-class"));
 class ImportWebhooks extends base_class_1.default {
     constructor({ importConfig, stackAPIClient }) {
         super({ importConfig, stackAPIClient });
-        this.importConfig.context.module = 'webhooks';
+        this.importConfig.context.module = utils_1.MODULE_CONTEXTS.WEBHOOKS;
+        this.currentModuleName = utils_1.MODULE_NAMES[utils_1.MODULE_CONTEXTS.WEBHOOKS];
         this.webhooksConfig = importConfig.modules.webhooks;
         this.mapperDirPath = (0, node_path_1.join)(this.importConfig.backupDir, 'mapper', 'webhooks');
         this.webhooksFolderPath = (0, node_path_1.join)(this.importConfig.backupDir, this.webhooksConfig.dirName);
@@ -27,46 +28,25 @@ class ImportWebhooks extends base_class_1.default {
      * @returns {Promise<void>} Promise<void>
      */
     async start() {
-        var _a, _b, _c;
-        cli_utilities_1.log.debug('Checking for webhooks folder existence', this.importConfig.context);
-        //Step1 check folder exists or not
-        if (utils_1.fileHelper.fileExistsSync(this.webhooksFolderPath)) {
-            this.webhooks = utils_1.fsUtil.readFile((0, node_path_1.join)(this.webhooksFolderPath, 'webhooks.json'), true);
-            cli_utilities_1.log.debug(`Found webhooks folder: ${this.webhooksFolderPath}`, this.importConfig.context);
-            const webhookCount = Object.keys(this.webhooks || {}).length;
-            cli_utilities_1.log.debug(`Loaded ${webhookCount} webhook items from file`, this.importConfig.context);
-        }
-        else {
-            cli_utilities_1.log.info(`No Webhooks Found - '${this.webhooksFolderPath}'`, this.importConfig.context);
-            return;
-        }
-        //create webhooks in mapper directory
-        cli_utilities_1.log.debug('Creating webhooks mapper directory', this.importConfig.context);
-        await utils_1.fsUtil.makeDirectory(this.mapperDirPath);
-        cli_utilities_1.log.debug('Created webhooks mapper directory', this.importConfig.context);
-        cli_utilities_1.log.debug('Loading existing webhook UID mappings', this.importConfig.context);
-        this.webhookUidMapper = utils_1.fileHelper.fileExistsSync(this.webhookUidMapperPath)
-            ? utils_1.fsUtil.readFile((0, node_path_1.join)(this.webhookUidMapperPath), true)
-            : {};
-        if (((_a = Object.keys(this.webhookUidMapper)) === null || _a === void 0 ? void 0 : _a.length) > 0) {
-            const webhookUidCount = Object.keys(this.webhookUidMapper || {}).length;
-            cli_utilities_1.log.debug(`Loaded existing webhook UID data: ${webhookUidCount} items`, this.importConfig.context);
-        }
-        else {
-            cli_utilities_1.log.debug('No existing webhook UID mappings found', this.importConfig.context);
-        }
-        cli_utilities_1.log.debug('Starting webhook import process', this.importConfig.context);
-        await this.importWebhooks();
-        cli_utilities_1.log.debug('Processing webhook import results', this.importConfig.context);
-        if ((_b = this.createdWebhooks) === null || _b === void 0 ? void 0 : _b.length) {
-            utils_1.fsUtil.writeFile(this.createdWebhooksPath, this.createdWebhooks);
-            cli_utilities_1.log.debug(`Written ${this.createdWebhooks.length} successful webhooks to file`, this.importConfig.context);
+        try {
+            cli_utilities_1.log.debug('Starting webhooks import process...', this.importConfig.context);
+            const [webhooksCount] = await this.analyzeWebhooks();
+            if (webhooksCount === 0) {
+                cli_utilities_1.log.info(`No Webhooks Found - '${this.webhooksFolderPath}'`, this.importConfig.context);
+                return;
+            }
+            const progress = this.createSimpleProgress(this.currentModuleName, webhooksCount);
+            await this.prepareWebhookMapper();
+            progress.updateStatus(utils_1.PROCESS_STATUS[utils_1.PROCESS_NAMES.WEBHOOKS_IMPORT].IMPORTING);
+            await this.importWebhooks();
+            this.processWebhookResults();
+            this.completeProgress(true);
+            cli_utilities_1.log.success('Webhooks have been imported successfully!', this.importConfig.context);
         }
-        if ((_c = this.failedWebhooks) === null || _c === void 0 ? void 0 : _c.length) {
-            utils_1.fsUtil.writeFile(this.failedWebhooksPath, this.failedWebhooks);
-            cli_utilities_1.log.debug(`Written ${this.failedWebhooks.length} failed webhooks to file`, this.importConfig.context);
+        catch (error) {
+            this.completeProgress(false, (error === null || error === void 0 ? void 0 : error.message) || 'Webhooks import failed');
+            (0, cli_utilities_1.handleAndLogError)(error, Object.assign({}, this.importConfig.context));
         }
-        cli_utilities_1.log.success('Webhooks have been imported successfully!', this.importConfig.context);
     }
     async importWebhooks() {
         cli_utilities_1.log.debug('Validating webhooks data', this.importConfig.context);
@@ -77,22 +57,26 @@ class ImportWebhooks extends base_class_1.default {
         const apiContent = (0, values_1.default)(this.webhooks);
         cli_utilities_1.log.debug(`Starting to import ${apiContent.length} webhooks`, this.importConfig.context);
         const onSuccess = ({ response, apiData: { uid, name } = { uid: null, name: '' } }) => {
+            var _a;
             this.createdWebhooks.push(response);
             this.webhookUidMapper[uid] = response.uid;
+            (_a = this.progressManager) === null || _a === void 0 ? void 0 : _a.tick(true, `webhook: ${name || uid}`, null, utils_1.PROCESS_NAMES.WEBHOOKS_IMPORT);
             cli_utilities_1.log.success(`Webhook '${name}' imported successfully`, this.importConfig.context);
             cli_utilities_1.log.debug(`Webhook UID mapping: ${uid} → ${response.uid}`, this.importConfig.context);
             utils_1.fsUtil.writeFile(this.webhookUidMapperPath, this.webhookUidMapper);
         };
         const onReject = ({ error, apiData }) => {
-            var _a;
+            var _a, _b, _c;
             const err = (error === null || error === void 0 ? void 0 : error.message) ? JSON.parse(error.message) : error;
             const { name, uid } = apiData;
             cli_utilities_1.log.debug(`Webhook '${name}' (${uid}) failed to import`, this.importConfig.context);
             if ((_a = err === null || err === void 0 ? void 0 : err.errors) === null || _a === void 0 ? void 0 : _a.name) {
+                (_b = this.progressManager) === null || _b === void 0 ? void 0 : _b.tick(true, `webhook: ${name || uid} (already exists)`, null, utils_1.PROCESS_NAMES.WEBHOOKS_IMPORT);
                 cli_utilities_1.log.info(`Webhook '${name}' already exists`, this.importConfig.context);
             }
             else {
                 this.failedWebhooks.push(apiData);
+                (_c = this.progressManager) === null || _c === void 0 ? void 0 : _c.tick(false, `webhook: ${name || uid}`, (error === null || error === void 0 ? void 0 : error.message) || utils_1.PROCESS_STATUS[utils_1.PROCESS_NAMES.WEBHOOKS_IMPORT].FAILED, utils_1.PROCESS_NAMES.WEBHOOKS_IMPORT);
                 (0, cli_utilities_1.handleAndLogError)(error, Object.assign(Object.assign({}, this.importConfig.context), { webhookName: name }), `Webhook '${name}' failed to import`);
             }
         };
@@ -117,11 +101,13 @@ class ImportWebhooks extends base_class_1.default {
      * @returns {ApiOptions} ApiOptions
      */
     serializeWebhooks(apiOptions) {
+        var _a;
         const { apiData: webhook } = apiOptions;
         cli_utilities_1.log.debug(`Serializing webhook: ${webhook.name} (${webhook.uid})`, this.importConfig.context);
         if (this.webhookUidMapper.hasOwnProperty(webhook.uid)) {
             cli_utilities_1.log.info(`Webhook '${webhook.name}' already exists. Skipping it to avoid duplicates!`, this.importConfig.context);
             cli_utilities_1.log.debug(`Skipping webhook serialization for: ${webhook.uid}`, this.importConfig.context);
+            (_a = this.progressManager) === null || _a === void 0 ? void 0 : _a.tick(true, `webhook: ${webhook.name} (skipped - already exists)`, null, utils_1.PROCESS_NAMES.WEBHOOKS_IMPORT);
             apiOptions.entity = undefined;
         }
         else {
@@ -137,5 +123,50 @@ class ImportWebhooks extends base_class_1.default {
         }
         return apiOptions;
     }
+    async analyzeWebhooks() {
+        return this.withLoadingSpinner('WEBHOOKS: Analyzing import data...', async () => {
+            cli_utilities_1.log.debug('Checking for webhooks folder existence', this.importConfig.context);
+            if (!utils_1.fileHelper.fileExistsSync(this.webhooksFolderPath)) {
+                cli_utilities_1.log.info(`No Webhooks Found - '${this.webhooksFolderPath}'`, this.importConfig.context);
+                return [0];
+            }
+            cli_utilities_1.log.debug(`Found webhooks folder: ${this.webhooksFolderPath}`, this.importConfig.context);
+            this.webhooks = utils_1.fsUtil.readFile((0, node_path_1.join)(this.webhooksFolderPath, 'webhooks.json'), true);
+            if (!this.webhooks) {
+                cli_utilities_1.log.info(`No webhooks found in file - '${(0, node_path_1.join)(this.webhooksFolderPath, 'webhooks.json')}'`, this.importConfig.context);
+                return [0];
+            }
+            const count = Object.keys(this.webhooks || {}).length;
+            cli_utilities_1.log.debug(`Loaded ${count} webhook items from file`, this.importConfig.context);
+            return [count];
+        });
+    }
+    async prepareWebhookMapper() {
+        cli_utilities_1.log.debug('Creating webhooks mapper directory', this.importConfig.context);
+        await utils_1.fsUtil.makeDirectory(this.mapperDirPath);
+        cli_utilities_1.log.debug('Loading existing webhook UID mappings', this.importConfig.context);
+        this.webhookUidMapper = utils_1.fileHelper.fileExistsSync(this.webhookUidMapperPath)
+            ? utils_1.fsUtil.readFile((0, node_path_1.join)(this.webhookUidMapperPath), true) || {}
+            : {};
+        const count = Object.keys(this.webhookUidMapper || {}).length;
+        if (count > 0) {
+            cli_utilities_1.log.debug(`Loaded existing webhook UID data: ${count} items`, this.importConfig.context);
+        }
+        else {
+            cli_utilities_1.log.debug('No existing webhook UID mappings found', this.importConfig.context);
+        }
+    }
+    processWebhookResults() {
+        var _a, _b;
+        cli_utilities_1.log.debug('Processing webhook import results', this.importConfig.context);
+        if ((_a = this.createdWebhooks) === null || _a === void 0 ? void 0 : _a.length) {
+            utils_1.fsUtil.writeFile(this.createdWebhooksPath, this.createdWebhooks);
+            cli_utilities_1.log.debug(`Written ${this.createdWebhooks.length} successful webhooks to file`, this.importConfig.context);
+        }
+        if ((_b = this.failedWebhooks) === null || _b === void 0 ? void 0 : _b.length) {
+            utils_1.fsUtil.writeFile(this.failedWebhooksPath, this.failedWebhooks);
+            cli_utilities_1.log.debug(`Written ${this.failedWebhooks.length} failed webhooks to file`, this.importConfig.context);
+        }
+    }
 }
 exports.default = ImportWebhooks;

package/lib/import/modules/workflows.d.ts

@@ -39,4 +39,7 @@ export default class ImportWorkflows extends BaseClass {
         stageIndex: number;
         roleData: any;
     }): void;
+    private analyzeWorkflows;
+    private prepareWorkflowMapper;
+    private processWorkflowResults;
 }

package/lib/import/modules/workflows.js

@@ -10,13 +10,14 @@ const filter_1 = tslib_1.__importDefault(require("lodash/filter"));
 const isEmpty_1 = tslib_1.__importDefault(require("lodash/isEmpty"));
 const cloneDeep_1 = tslib_1.__importDefault(require("lodash/cloneDeep"));
 const findIndex_1 = tslib_1.__importDefault(require("lodash/findIndex"));
+const cli_utilities_1 = require("@contentstack/cli-utilities");
 const base_class_1 = tslib_1.__importDefault(require("./base-class"));
 const utils_1 = require("../../utils");
-const cli_utilities_1 = require("@contentstack/cli-utilities");
 class ImportWorkflows extends base_class_1.default {
     constructor({ importConfig, stackAPIClient }) {
         super({ importConfig, stackAPIClient });
-        this.importConfig.context.module = 'workflows';
+        this.importConfig.context.module = utils_1.MODULE_CONTEXTS.WORKFLOWS;
+        this.currentModuleName = utils_1.MODULE_NAMES[utils_1.MODULE_CONTEXTS.WORKFLOWS];
         this.workflowsConfig = importConfig.modules.workflows;
         this.mapperDirPath = (0, node_path_1.join)(this.importConfig.backupDir, 'mapper', 'workflows');
         this.workflowsFolderPath = (0, node_path_1.join)(this.importConfig.backupDir, this.workflowsConfig.dirName);
@@ -34,52 +35,39 @@ class ImportWorkflows extends base_class_1.default {
      * @returns {Promise<void>} Promise<void>
      */
     async start() {
-        var _a, _b, _c;
-        cli_utilities_1.log.debug('Checking for workflows folder existence', this.importConfig.context);
-        //Step1 check folder exists or not
-        if (utils_1.fileHelper.fileExistsSync(this.workflowsFolderPath)) {
-            cli_utilities_1.log.debug(`Found workflows folder: ${this.workflowsFolderPath}`, this.importConfig.context);
-            this.workflows = utils_1.fsUtil.readFile((0, node_path_1.join)(this.workflowsFolderPath, this.workflowsConfig.fileName), true);
-            const workflowCount = Object.keys(this.workflows || {}).length;
-            cli_utilities_1.log.debug(`Loaded ${workflowCount} workflow items from file`, this.importConfig.context);
-        }
-        else {
-            cli_utilities_1.log.info(`No Workflows Found - '${this.workflowsFolderPath}'`, this.importConfig.context);
-            return;
-        }
-        //create workflows in mapper directory
-        cli_utilities_1.log.debug('Creating workflows mapper directory', this.importConfig.context);
-        await utils_1.fsUtil.makeDirectory(this.mapperDirPath);
-        cli_utilities_1.log.debug('Loading existing workflow UID mappings', this.importConfig.context);
-        this.workflowUidMapper = utils_1.fileHelper.fileExistsSync(this.workflowUidMapperPath)
-            ? utils_1.fsUtil.readFile((0, node_path_1.join)(this.workflowUidMapperPath), true)
-            : {};
-        if (((_a = Object.keys(this.workflowUidMapper)) === null || _a === void 0 ? void 0 : _a.length) > 0) {
-            const workflowUidCount = Object.keys(this.workflowUidMapper || {}).length;
-            cli_utilities_1.log.debug(`Loaded existing workflow UID data: ${workflowUidCount} items`, this.importConfig.context);
-        }
-        else {
-            cli_utilities_1.log.debug('No existing workflow UID mappings found', this.importConfig.context);
-        }
-        if (this.workflows === undefined || (0, isEmpty_1.default)(this.workflows)) {
-            cli_utilities_1.log.info('No Workflow Found', this.importConfig.context);
-            return;
-        }
-        //fetch all roles
-        cli_utilities_1.log.debug('Fetching all roles for workflow processing', this.importConfig.context);
-        await this.getRoles();
-        cli_utilities_1.log.debug('Starting workflow import process', this.importConfig.context);
-        await this.importWorkflows();
-        cli_utilities_1.log.debug('Processing workflow import results', this.importConfig.context);
-        if ((_b = this.createdWorkflows) === null || _b === void 0 ? void 0 : _b.length) {
-            utils_1.fsUtil.writeFile(this.createdWorkflowsPath, this.createdWorkflows);
-            cli_utilities_1.log.debug(`Written ${this.createdWorkflows.length} successful workflows to file`, this.importConfig.context);
+        try {
+            cli_utilities_1.log.debug('Starting workflows import process...', this.importConfig.context);
+            const [workflowsCount] = await this.analyzeWorkflows();
+            if (workflowsCount === 0) {
+                cli_utilities_1.log.info(`No Workflows Found - '${this.workflowsFolderPath}'`, this.importConfig.context);
+                return;
+            }
+            const progress = this.createNestedProgress(this.currentModuleName);
+            progress.addProcess(utils_1.PROCESS_NAMES.GET_ROLES, 1);
+            progress.addProcess(utils_1.PROCESS_NAMES.WORKFLOWS_CREATE, workflowsCount);
+            await this.prepareWorkflowMapper();
+            // Step 1: Fetch and setup roles
+            progress
+                .startProcess(utils_1.PROCESS_NAMES.GET_ROLES)
+                .updateStatus(utils_1.PROCESS_STATUS[utils_1.PROCESS_NAMES.GET_ROLES].FETCHING, utils_1.PROCESS_NAMES.GET_ROLES);
+            cli_utilities_1.log.info('Fetching all roles for workflow processing', this.importConfig.context);
+            await this.getRoles();
+            progress.completeProcess(utils_1.PROCESS_NAMES.GET_ROLES, true);
+            // Step 2: Import workflows
+            progress
+                .startProcess(utils_1.PROCESS_NAMES.WORKFLOWS_CREATE)
+                .updateStatus(utils_1.PROCESS_STATUS[utils_1.PROCESS_NAMES.WORKFLOWS_CREATE].IMPORTING, utils_1.PROCESS_NAMES.WORKFLOWS_CREATE);
+            cli_utilities_1.log.info('Starting workflows import process', this.importConfig.context);
+            await this.importWorkflows();
+            progress.completeProcess(utils_1.PROCESS_NAMES.WORKFLOWS_CREATE, true);
+            this.processWorkflowResults();
+            this.completeProgress(true);
+            cli_utilities_1.log.success('Workflows have been imported successfully!', this.importConfig.context);
         }
-        if ((_c = this.failedWebhooks) === null || _c === void 0 ? void 0 : _c.length) {
-            utils_1.fsUtil.writeFile(this.failedWorkflowsPath, this.failedWebhooks);
-            cli_utilities_1.log.debug(`Written ${this.failedWebhooks.length} failed workflows to file`, this.importConfig.context);
+        catch (error) {
+            this.completeProgress(false, (error === null || error === void 0 ? void 0 : error.message) || 'Workflows import failed');
+            (0, cli_utilities_1.handleAndLogError)(error, Object.assign({}, this.importConfig.context));
         }
-        cli_utilities_1.log.success('Workflows have been imported successfully!', this.importConfig.context);
     }
     async getRoles() {
         cli_utilities_1.log.debug('Fetching roles from stack', this.importConfig.context);
@@ -119,12 +107,14 @@ class ImportWorkflows extends base_class_1.default {
             }
         }
         const onSuccess = async ({ response, apiData: { uid, name } = { uid: null, name: '' } }) => {
-            var _a;
+            var _a, _b;
             cli_utilities_1.log.debug(`Workflow '${name}' imported successfully, processing next available stages`, this.importConfig.context);
             const oldWorkflowStages = (_a = (0, find_1.default)(oldWorkflows, { uid })) === null || _a === void 0 ? void 0 : _a.workflow_stages;
             if (!(0, isEmpty_1.default)((0, filter_1.default)(oldWorkflowStages, ({ next_available_stages }) => !(0, isEmpty_1.default)(next_available_stages)))) {
                 cli_utilities_1.log.debug(`Updating next available stages for workflow '${name}'`, this.importConfig.context);
                 let updateRresponse = await this.updateNextAvailableStagesUid(response, response.workflow_stages, oldWorkflowStages).catch((error) => {
+                    var _a;
+                    (_a = this.progressManager) === null || _a === void 0 ? void 0 : _a.tick(false, `workflow: ${name || uid}`, (error === null || error === void 0 ? void 0 : error.message) || 'Failed to update next available stages', utils_1.PROCESS_NAMES.WORKFLOWS_CREATE);
                     (0, cli_utilities_1.handleAndLogError)(error, Object.assign(Object.assign({}, this.importConfig.context), { name }), `Workflow '${name}' update failed`);
                 });
                 if (updateRresponse) {
@@ -134,21 +124,24 @@ class ImportWorkflows extends base_class_1.default {
             }
             this.createdWorkflows.push(response);
             this.workflowUidMapper[uid] = response.uid;
+            (_b = this.progressManager) === null || _b === void 0 ? void 0 : _b.tick(true, `workflow: ${name || uid}`, null, utils_1.PROCESS_NAMES.WORKFLOWS_CREATE);
             cli_utilities_1.log.success(`Workflow '${name}' imported successfully`, this.importConfig.context);
             cli_utilities_1.log.debug(`Workflow UID mapping: ${uid} → ${response.uid}`, this.importConfig.context);
             utils_1.fsUtil.writeFile(this.workflowUidMapperPath, this.workflowUidMapper);
         };
         const onReject = ({ error, apiData }) => {
-            var _a, _b;
+            var _a, _b, _c, _d;
             const err = (error === null || error === void 0 ? void 0 : error.message) ? JSON.parse(error.message) : error;
             const { name, uid } = apiData;
             cli_utilities_1.log.debug(`Workflow '${name}' (${uid}) failed to import`, this.importConfig.context);
             const workflowExists = ((_a = err === null || err === void 0 ? void 0 : err.errors) === null || _a === void 0 ? void 0 : _a.name) || ((_b = err === null || err === void 0 ? void 0 : err.errors) === null || _b === void 0 ? void 0 : _b['workflow.name']);
             if (workflowExists) {
+                (_c = this.progressManager) === null || _c === void 0 ? void 0 : _c.tick(true, `workflow: ${name || uid} (already exists)`, null, utils_1.PROCESS_NAMES.WORKFLOWS_CREATE);
                 cli_utilities_1.log.info(`Workflow '${name}' already exists`, this.importConfig.context);
             }
             else {
                 this.failedWebhooks.push(apiData);
+                (_d = this.progressManager) === null || _d === void 0 ? void 0 : _d.tick(false, `workflow: ${name || uid}`, (error === null || error === void 0 ? void 0 : error.message) || 'Failed to import workflow', utils_1.PROCESS_NAMES.WORKFLOWS_CREATE);
                 if (error.errors['workflow_stages.0.users']) {
                     cli_utilities_1.log.error("Failed to import Workflows as you've specified certain roles in the Stage transition and access rules section. We currently don't import roles to the stack.", this.importConfig.context);
                 }
@@ -201,9 +194,13 @@ class ImportWorkflows extends base_class_1.default {
      * @returns {ApiOptions} ApiOptions
      */
     serializeWorkflows(apiOptions) {
+        var _a;
         let { apiData: workflow } = apiOptions;
+        cli_utilities_1.log.debug(`Serializing workflow: ${workflow.name} (${workflow.uid})`, this.importConfig.context);
         if (this.workflowUidMapper.hasOwnProperty(workflow.uid)) {
             cli_utilities_1.log.info(`Workflow '${workflow.name}' already exists. Skipping it to avoid duplicates!`, this.importConfig.context);
+            cli_utilities_1.log.debug(`Skipping workflow serialization for: ${workflow.uid}`, this.importConfig.context);
+            (_a = this.progressManager) === null || _a === void 0 ? void 0 : _a.tick(true, `workflow: ${workflow.name} (skipped - already exists)`, null, utils_1.PROCESS_NAMES.WORKFLOWS_CREATE);
             apiOptions.entity = undefined;
         }
         else {
@@ -221,6 +218,7 @@ class ImportWorkflows extends base_class_1.default {
                     stage.next_available_stages = ['$all'];
                 }
             }
+            cli_utilities_1.log.debug(`Workflow serialization completed: ${workflow.name}`, this.importConfig.context);
             apiOptions.apiData = workflow;
         }
         return apiOptions;
@@ -231,8 +229,10 @@ class ImportWorkflows extends base_class_1.default {
             const { name } = apiData;
             this.updateRoleData({ workflowUid, stageIndex, roleData: apiData });
             this.roleNameMap[name] = response === null || response === void 0 ? void 0 : response.uid;
+            cli_utilities_1.log.debug(`Custom role '${name}' created successfully for workflow`, this.importConfig.context);
         };
         const onReject = ({ error, apiData: { name } = { name: '' } }) => {
+            cli_utilities_1.log.debug(`Custom role '${name}' creation failed`, this.importConfig.context);
             (0, cli_utilities_1.handleAndLogError)(error, Object.assign(Object.assign({}, this.importConfig.context), { name }), `Failed to create custom roles '${name}'`);
         };
         const workflowStages = workflow.workflow_stages;
@@ -243,6 +243,7 @@ class ImportWorkflows extends base_class_1.default {
             }
             if ((_h = (_g = (_f = stage === null || stage === void 0 ? void 0 : stage.SYS_ACL) === null || _f === void 0 ? void 0 : _f.roles) === null || _g === void 0 ? void 0 : _g.uids) === null || _h === void 0 ? void 0 : _h.length) {
                 const apiContent = stage.SYS_ACL.roles.uids;
+                cli_utilities_1.log.debug(`Creating ${apiContent.length} custom roles for workflow stage ${stageIndex}`, this.importConfig.context);
                 await this.makeConcurrentCall({
                     apiContent,
                     processName: 'create custom role',
@@ -267,6 +268,7 @@ class ImportWorkflows extends base_class_1.default {
      */
     serializeCustomRoles(apiOptions) {
         let { apiData: roleData, additionalInfo: { workflowUid, stageIndex }, } = apiOptions;
+        cli_utilities_1.log.debug(`Serializing custom role: ${roleData.name}`, this.importConfig.context);
         if (!this.roleNameMap[roleData.name]) {
             // rules.branch is required to create custom roles.
             const branchRuleExists = (0, find_1.default)(roleData.rules, (rule) => rule.module === 'branch');
@@ -276,10 +278,12 @@ class ImportWorkflows extends base_class_1.default {
                     branches: ['main'],
                     acl: { read: true },
                 });
+                cli_utilities_1.log.debug(`Added branch rule to custom role: ${roleData.name}`, this.importConfig.context);
             }
             apiOptions = roleData;
         }
         else {
+            cli_utilities_1.log.debug(`Custom role '${roleData.name}' already exists, skipping creation`, this.importConfig.context);
             apiOptions.entity = undefined;
             this.updateRoleData({ workflowUid, stageIndex, roleData });
         }
@@ -291,6 +295,52 @@ class ImportWorkflows extends base_class_1.default {
         const roles = workflowStage[stageIndex].SYS_ACL.roles.uids;
         const index = (0, findIndex_1.default)(roles, ['uid', roleData.uid]);
         roles[index >= 0 ? index : roles.length] = this.roleNameMap[roleData.name];
+        cli_utilities_1.log.debug(`Updated role data for workflow ${workflowUid}, stage ${stageIndex}`, this.importConfig.context);
+    }
+    async analyzeWorkflows() {
+        return this.withLoadingSpinner('WORKFLOWS: Analyzing import data...', async () => {
+            cli_utilities_1.log.debug('Checking for workflows folder existence', this.importConfig.context);
+            if (!utils_1.fileHelper.fileExistsSync(this.workflowsFolderPath)) {
+                cli_utilities_1.log.info(`No Workflows Found - '${this.workflowsFolderPath}'`, this.importConfig.context);
+                return [0];
+            }
+            cli_utilities_1.log.debug(`Found workflows folder: ${this.workflowsFolderPath}`, this.importConfig.context);
+            this.workflows = utils_1.fsUtil.readFile((0, node_path_1.join)(this.workflowsFolderPath, this.workflowsConfig.fileName), true);
+            if (!this.workflows || (0, isEmpty_1.default)(this.workflows)) {
+                cli_utilities_1.log.info(`No workflows found in file - '${(0, node_path_1.join)(this.workflowsFolderPath, this.workflowsConfig.fileName)}'`, this.importConfig.context);
+                return [0];
+            }
+            const count = Object.keys(this.workflows || {}).length;
+            cli_utilities_1.log.debug(`Loaded ${count} workflow items from file`, this.importConfig.context);
+            return [count];
+        });
+    }
+    async prepareWorkflowMapper() {
+        cli_utilities_1.log.debug('Creating workflows mapper directory', this.importConfig.context);
+        await utils_1.fsUtil.makeDirectory(this.mapperDirPath);
+        cli_utilities_1.log.debug('Loading existing workflow UID mappings', this.importConfig.context);
+        this.workflowUidMapper = utils_1.fileHelper.fileExistsSync(this.workflowUidMapperPath)
+            ? utils_1.fsUtil.readFile((0, node_path_1.join)(this.workflowUidMapperPath), true) || {}
+            : {};
+        const count = Object.keys(this.workflowUidMapper || {}).length;
+        if (count > 0) {
+            cli_utilities_1.log.debug(`Loaded existing workflow UID data: ${count} items`, this.importConfig.context);
+        }
+        else {
+            cli_utilities_1.log.debug('No existing workflow UID mappings found', this.importConfig.context);
+        }
+    }
+    processWorkflowResults() {
+        var _a, _b;
+        cli_utilities_1.log.debug('Processing workflow import results', this.importConfig.context);
+        if ((_a = this.createdWorkflows) === null || _a === void 0 ? void 0 : _a.length) {
+            utils_1.fsUtil.writeFile(this.createdWorkflowsPath, this.createdWorkflows);
+            cli_utilities_1.log.debug(`Written ${this.createdWorkflows.length} successful workflows to file`, this.importConfig.context);
+        }
+        if ((_b = this.failedWebhooks) === null || _b === void 0 ? void 0 : _b.length) {
+            utils_1.fsUtil.writeFile(this.failedWorkflowsPath, this.failedWebhooks);
+            cli_utilities_1.log.debug(`Written ${this.failedWebhooks.length} failed workflows to file`, this.importConfig.context);
+        }
     }
 }
 exports.default = ImportWorkflows;

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

@@ -183,7 +183,6 @@ export default interface DefaultConfig {
     getEncryptionKeyMaxRetry: number;
     createBackupDir?: string;
     overwriteSupportedModules: string[];
-    onlyTSModules: string[];
     auditConfig?: {
         noLog?: boolean;
         skipConfirm?: boolean;

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

@@ -48,7 +48,6 @@ export default interface ImportConfig extends DefaultConfig, ExternalConfig {
     authtoken?: string;
     destinationStackName?: string;
     org_uid?: string;
-    contentVersion: number;
     replaceExisting?: boolean;
     skipExisting?: boolean;
     skipAudit?: boolean;

package/lib/types/index.d.ts

@@ -71,17 +71,6 @@ export interface TaxonomiesConfig {
     fileName: string;
     dependencies?: Modules[];
 }
-export interface Context {
-    command: string;
-    module: string;
-    userId: string | undefined;
-    email: string | undefined;
-    sessionId: string | undefined;
-    clientId?: string | undefined;
-    apiKey: string;
-    orgId: string;
-    authenticationMethod?: string;
-}
 export { default as DefaultConfig } from './default-config';
 export { default as ImportConfig } from './import-config';
 export * from './entries';
@@ -95,7 +84,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/backup-handler.js

@@ -45,7 +45,6 @@ async function backupHandler(importConfig) {
         return new Promise((resolve, reject) => {
             return (0, fs_extra_1.copy)(sourceDir, backupDirPath, (error) => {
                 if (error) {
-                    (0, index_1.trace)(error, 'error', true);
                     return reject(error);
                 }
                 cli_utilities_1.log.debug(`Successfully created backup at: ${backupDirPath}`);