@contentstack/cli-cm-import 1.7.1 → 1.8.0

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

@@ -0,0 +1,41 @@
+import BaseClass, { ApiOptions } from './base-class';
+import { ModuleClassParams } from '../../types';
+export default class ImportWorkflows extends BaseClass {
+    private mapperDirPath;
+    private workflowsFolderPath;
+    private workflowUidMapperPath;
+    private createdWorkflowsPath;
+    private failedWorkflowsPath;
+    private workflowsConfig;
+    private workflows;
+    private workflowUidMapper;
+    private createdWorkflows;
+    private failedWebhooks;
+    private roleNameMap;
+    constructor({ importConfig, stackAPIClient }: ModuleClassParams);
+    /**
+     * @method start
+     * @returns {Promise<void>} Promise<void>
+     */
+    start(): Promise<void>;
+    getRoles(): Promise<void>;
+    importWorkflows(): Promise<void>;
+    /**
+     * @method serializeWorkflows
+     * @param {ApiOptions} apiOptions ApiOptions
+     * @returns {ApiOptions} ApiOptions
+     */
+    serializeWorkflows(apiOptions: ApiOptions): ApiOptions;
+    createCustomRoleIfNotExists(workflow: Record<string, any>): Promise<void>;
+    /**
+     * @method serializeCustomRoles
+     * @param {ApiOptions} apiOptions ApiOptions
+     * @returns {ApiOptions} ApiOptions
+     */
+    serializeCustomRoles(apiOptions: ApiOptions): ApiOptions;
+    updateRoleData(params: {
+        workflowUid: string;
+        stageIndex: number;
+        roleData: any;
+    }): void;
+}

package/lib/import/modules/workflows.js

@@ -0,0 +1,209 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const isEmpty_1 = tslib_1.__importDefault(require("lodash/isEmpty"));
+const values_1 = tslib_1.__importDefault(require("lodash/values"));
+const find_1 = tslib_1.__importDefault(require("lodash/find"));
+const findIndex_1 = tslib_1.__importDefault(require("lodash/findIndex"));
+const node_path_1 = require("node:path");
+const config_1 = tslib_1.__importDefault(require("../../config"));
+const base_class_1 = tslib_1.__importDefault(require("./base-class"));
+const utils_1 = require("../../utils");
+class ImportWorkflows extends base_class_1.default {
+    constructor({ importConfig, stackAPIClient }) {
+        super({ importConfig, stackAPIClient });
+        this.workflowsConfig = config_1.default.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);
+        this.workflowUidMapperPath = (0, node_path_1.join)(this.mapperDirPath, 'uid-mapping.json');
+        this.createdWorkflowsPath = (0, node_path_1.join)(this.mapperDirPath, 'success.json');
+        this.failedWorkflowsPath = (0, node_path_1.join)(this.mapperDirPath, 'fails.json');
+        this.workflows = {};
+        this.failedWebhooks = [];
+        this.createdWorkflows = [];
+        this.workflowUidMapper = {};
+        this.roleNameMap = {};
+    }
+    /**
+     * @method start
+     * @returns {Promise<void>} Promise<void>
+     */
+    async start() {
+        var _a, _b;
+        (0, utils_1.log)(this.importConfig, 'Migrating workflows', 'info');
+        //Step1 check folder exists or not
+        if (utils_1.fileHelper.fileExistsSync(this.workflowsFolderPath)) {
+            this.workflows = utils_1.fsUtil.readFile((0, node_path_1.join)(this.workflowsFolderPath, this.workflowsConfig.fileName), true);
+        }
+        else {
+            (0, utils_1.log)(this.importConfig, `No such file or directory - '${this.workflowsFolderPath}'`, 'error');
+            return;
+        }
+        //create workflows in mapper directory
+        await utils_1.fsUtil.makeDirectory(this.mapperDirPath);
+        this.workflowUidMapper = utils_1.fileHelper.fileExistsSync(this.workflowUidMapperPath)
+            ? utils_1.fsUtil.readFile((0, node_path_1.join)(this.workflowUidMapperPath), true)
+            : {};
+        if (this.workflows === undefined || (0, isEmpty_1.default)(this.workflows)) {
+            (0, utils_1.log)(this.importConfig, 'No Workflow Found', 'info');
+            return;
+        }
+        //fetch all roles
+        await this.getRoles();
+        await this.importWorkflows();
+        if ((_a = this.createdWorkflows) === null || _a === void 0 ? void 0 : _a.length) {
+            utils_1.fsUtil.writeFile(this.createdWorkflowsPath, this.createdWorkflows);
+        }
+        if ((_b = this.failedWebhooks) === null || _b === void 0 ? void 0 : _b.length) {
+            utils_1.fsUtil.writeFile(this.failedWorkflowsPath, this.failedWebhooks);
+        }
+        (0, utils_1.log)(this.importConfig, 'Workflows have been imported successfully!', 'success');
+    }
+    async getRoles() {
+        const roles = await this.stack
+            .role()
+            .fetchAll()
+            .then((data) => data)
+            .catch((err) => (0, utils_1.log)(this.importConfig, `Failed to fetch roles. ${(0, utils_1.formatError)(err)}`, 'error'));
+        for (const role of roles === null || roles === void 0 ? void 0 : roles.items) {
+            this.roleNameMap[role.name] = role.uid;
+        }
+    }
+    async importWorkflows() {
+        const apiContent = (0, values_1.default)(this.workflows);
+        //check and create custom roles if not exists
+        for (const workflow of (0, values_1.default)(this.workflows)) {
+            if (!this.workflowUidMapper.hasOwnProperty(workflow.uid)) {
+                await this.createCustomRoleIfNotExists(workflow);
+            }
+        }
+        const onSuccess = ({ response, apiData: { uid, name } = { uid: null, name: '' } }) => {
+            this.createdWorkflows.push(response);
+            this.workflowUidMapper[uid] = response.uid;
+            (0, utils_1.log)(this.importConfig, `Workflow '${name}' imported successfully`, 'success');
+            utils_1.fsUtil.writeFile(this.workflowUidMapperPath, this.workflowUidMapper);
+        };
+        const onReject = ({ error, apiData }) => {
+            var _a;
+            const err = (error === null || error === void 0 ? void 0 : error.message) ? JSON.parse(error.message) : error;
+            const { name } = apiData;
+            if ((_a = err === null || err === void 0 ? void 0 : err.errors) === null || _a === void 0 ? void 0 : _a.name) {
+                (0, utils_1.log)(this.importConfig, `Workflow '${name}' already exists`, 'info');
+            }
+            else {
+                this.failedWebhooks.push(apiData);
+                if (error.errors['workflow_stages.0.users']) {
+                    (0, utils_1.log)(this.importConfig, "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.", 'error');
+                }
+                else {
+                    (0, utils_1.log)(this.importConfig, `Workflow '${name}' failed to be import. ${(0, utils_1.formatError)(error)}`, 'error');
+                }
+            }
+        };
+        await this.makeConcurrentCall({
+            apiContent,
+            processName: 'create workflows',
+            apiParams: {
+                serializeData: this.serializeWorkflows.bind(this),
+                reject: onReject,
+                resolve: onSuccess,
+                entity: 'create-workflows',
+                includeParamOnCompletion: true,
+            },
+            concurrencyLimit: config_1.default.fetchConcurrency || 1,
+        }, undefined, false);
+    }
+    /**
+     * @method serializeWorkflows
+     * @param {ApiOptions} apiOptions ApiOptions
+     * @returns {ApiOptions} ApiOptions
+     */
+    serializeWorkflows(apiOptions) {
+        let { apiData: workflow } = apiOptions;
+        if (this.workflowUidMapper.hasOwnProperty(workflow.uid)) {
+            (0, utils_1.log)(this.importConfig, `Workflow '${workflow.name}' already exists. Skipping it to avoid duplicates!`, 'info');
+            apiOptions.entity = undefined;
+        }
+        else {
+            if (workflow.admin_users !== undefined) {
+                (0, utils_1.log)(this.importConfig, chalk_1.default.yellow('We are skipping import of `Workflow superuser(s)` from workflow'), 'info');
+                delete workflow.admin_users;
+            }
+            // One branch is required to create workflow.
+            if (!workflow.branches) {
+                workflow.branches = ['main'];
+            }
+            apiOptions.apiData = workflow;
+        }
+        return apiOptions;
+    }
+    async createCustomRoleIfNotExists(workflow) {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        const onSuccess = ({ response, apiData, additionalInfo: { workflowUid, stageIndex } }) => {
+            const { name } = apiData;
+            this.updateRoleData({ workflowUid, stageIndex, roleData: apiData });
+            this.roleNameMap[name] = response === null || response === void 0 ? void 0 : response.uid;
+        };
+        const onReject = ({ error, apiData: { name } = { name: '' } }) => {
+            (0, utils_1.log)(this.importConfig, `Failed to create custom roles '${name}'.${(0, utils_1.formatError)(error)}`, 'error');
+        };
+        const workflowStages = workflow.workflow_stages;
+        let stageIndex = 0;
+        for (const stage of workflowStages) {
+            if (((_c = (_b = (_a = stage === null || stage === void 0 ? void 0 : stage.SYS_ACL) === null || _a === void 0 ? void 0 : _a.users) === null || _b === void 0 ? void 0 : _b.uids) === null || _c === void 0 ? void 0 : _c.length) && ((_e = (_d = stage === null || stage === void 0 ? void 0 : stage.SYS_ACL) === null || _d === void 0 ? void 0 : _d.users) === null || _e === void 0 ? void 0 : _e.uids[0]) !== '$all') {
+                stage.SYS_ACL.users.uids = ['$all'];
+            }
+            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;
+                await this.makeConcurrentCall({
+                    apiContent,
+                    processName: 'create custom role',
+                    apiParams: {
+                        serializeData: this.serializeCustomRoles.bind(this),
+                        reject: onReject,
+                        resolve: onSuccess,
+                        entity: 'create-custom-role',
+                        includeParamOnCompletion: true,
+                        additionalInfo: { workflowUid: workflow.uid, stageIndex },
+                    },
+                    concurrencyLimit: config_1.default.fetchConcurrency || 1,
+                }, undefined, false);
+            }
+            stageIndex++;
+        }
+    }
+    /**
+     * @method serializeCustomRoles
+     * @param {ApiOptions} apiOptions ApiOptions
+     * @returns {ApiOptions} ApiOptions
+     */
+    serializeCustomRoles(apiOptions) {
+        let { apiData: roleData, additionalInfo: { workflowUid, stageIndex }, } = apiOptions;
+        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');
+            if (!branchRuleExists) {
+                roleData.rules.push({
+                    module: 'branch',
+                    branches: ['main'],
+                    acl: { read: true },
+                });
+            }
+            apiOptions = roleData;
+        }
+        else {
+            apiOptions.entity = undefined;
+            this.updateRoleData({ workflowUid, stageIndex, roleData });
+        }
+        return apiOptions;
+    }
+    updateRoleData(params) {
+        const { workflowUid, stageIndex, roleData } = params;
+        const workflowStage = this.workflows[workflowUid].workflow_stages;
+        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];
+    }
+}
+exports.default = ImportWorkflows;

package/lib/import/modules-js/custom-roles.js

@@ -74,7 +74,7 @@ module.exports = class ImportCustomRoles {
                 catch (error) {
                     self.fails.push(customRole);
                     if (((error && error.errors && error.errors.name) || '').includes('is not a unique.')) {
-                        log(self.config, `custom-role ${customRole.name} already exists`, 'info');
+                        log(self.config, `custom-role '${customRole.name}' already exists`, 'info');
                     }
                     else {
                         if (!(error && error.errors && error.errors.name)) {

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

@@ -324,12 +324,12 @@ module.exports = class ImportEntries {
                                     }
                                 })
                                     .catch((error) => {
-                                    if (error.hasOwnProperty('error_code') && error.error_code === 119) {
+                                    if (error.hasOwnProperty('errorCode') && error.errorCode === 119) {
                                         if (error.errors.title) {
                                             log(this.config, 'Entry ' + eUid + ' already exist, skip to avoid creating a duplicate entry', 'error');
                                         }
                                         else {
-                                            log(this.config, `Failed to create an entry ${eUid} ${formatError(error)}`, 'error');
+                                            log(this.config, `Failed to create an entry '${eUid}' ${formatError(error)} Title of the failed entry: '${entries[eUid].title}'`, 'error');
                                         }
                                         self.createdEntriesWOUid.push({
                                             content_type: ctUid,
@@ -342,7 +342,7 @@ module.exports = class ImportEntries {
                                     }
                                     // TODO: if status code: 422, check the reason
                                     // 429 for rate limit
-                                    log(this.config, `Failed to create an entry ${eUid} ${formatError(error)}`, 'error');
+                                    log(this.config, `Failed to create an entry '${eUid}' ${formatError(error)}. Title of the failed entry: '${entries[eUid].title}'`, 'error');
                                     self.fails.push({
                                         content_type: ctUid,
                                         locale: lang,
@@ -394,7 +394,13 @@ module.exports = class ImportEntries {
                 return resolve();
             })
                 .catch((error) => {
-                addlogs(this.config, chalk.red("Failed to create entries in '" + lang + "' language"), 'error');
+                var _a, _b;
+                let title = (_b = JSON.parse(((_a = error === null || error === void 0 ? void 0 : error.request) === null || _a === void 0 ? void 0 : _a.data) || "{}").entry) === null || _b === void 0 ? void 0 : _b.title;
+                addlogs(this.config, chalk.red("Failed to create entries in '" +
+                    lang +
+                    "' language. " +
+                    'Title of the failed entry: ' +
+                    `'${title || ""}'`), 'error');
                 return reject(error);
             });
         });
@@ -473,7 +479,7 @@ module.exports = class ImportEntries {
                         return _entry;
                     }
                     catch (error) {
-                        addlogs(this.config, `Failed to update the entry ${uid} references while reposting ${formatError(error)}`, 'error');
+                        addlogs(this.config, `Failed to update the entry '${uid}' references while reposting ${formatError(error)}`, 'error');
                     }
                 });
                 log(this.config, 'Starting the reposting process for entries');
@@ -544,7 +550,7 @@ module.exports = class ImportEntries {
                 })
                     .catch((error) => {
                     // error while updating entries with references
-                    addlogs(this.config, `Failed re-post entries of content type ${ctUid} locale ${lang}`, 'error');
+                    addlogs(this.config, `Failed re-post entries of content type '${ctUid}' locale '${lang}'`, 'error');
                     addlogs(this.config, formatError(error), 'error');
                     // throw error;
                 });
@@ -620,7 +626,7 @@ module.exports = class ImportEntries {
                 })
                     .catch((_error) => {
                     addlogs(this.config, formatError(_error), 'error');
-                    reject(`Failed suppress content type ${schema.uid} reference fields`);
+                    reject(`Failed suppress content type '${schema.uid}' reference fields`);
                 });
                 // update 5 content types at a time
             }, {

package/lib/import/modules-js/environments.js

@@ -67,7 +67,7 @@ module.exports = class ImportEnvironments {
                 }
                 else {
                     // the environment has already been created
-                    log(config, `The environment ${env.name} already exists. Skipping it to avoid duplicates!`, 'success');
+                    log(config, `The environment '${env.name}' already exists. Skipping it to avoid duplicates!`, 'success');
                 }
             }, { concurrency: self.fetchConcurrency })
                 .then(function () {

package/lib/import/modules-js/extensions.js

@@ -59,7 +59,7 @@ module.exports = class ImportExtensions {
                             log(self.config, `Extension '${ext.title}' already exists`, 'error');
                         }
                         else {
-                            log(self.config, "Extension: '" + ext.title + "' failed to be import" + formatError(error), 'error');
+                            log(self.config, "Extension: '" + ext.title + "' failed to import" + formatError(error), 'error');
                         }
                     });
                 }

package/lib/import/modules-js/global-fields.js

@@ -71,13 +71,14 @@ module.exports = class ImportGlobalFields {
                         log(self.config, chalk.green('Global field ' + global_field_uid + ' created successfully'), 'success');
                     })
                         .catch(function (err) {
+                        console.log;
                         let error = JSON.parse(err.message);
                         if (error.errors.title) {
                             // eslint-disable-next-line no-undef
                             log(self.config, `Globalfield '${snip.uid} already exists'`, 'error');
                         }
                         else {
-                            log(self.config, chalk.red(`Globalfield failed to import ${formatError(error)}`), 'error');
+                            log(self.config, chalk.red(`Globalfield '${snip.title}' failed to import. ${formatError(error)}`), 'error');
                         }
                         self.fails.push(snip);
                     });
@@ -96,10 +97,7 @@ module.exports = class ImportGlobalFields {
                 return resolve();
             })
                 .catch(function (err) {
-                // error while importing globalfields
                 let error = JSON.parse(err);
-                // error while importing globalfields
-                log(self.config, err, 'error');
                 fileHelper.writeFileSync(globalfieldsFailsPath, self.fails);
                 log(self.config, `Globalfields import failed. ${formatError(err)}`, 'error');
                 return reject(error);

package/lib/import/modules-js/marketplace-apps.d.ts

@@ -3,7 +3,7 @@ declare class ImportMarketplaceApps {
     constructor(importConfig: any, stackAPIClient: any);
     client: any;
     httpClient: any;
-    appOrginalName: any;
+    appOriginalName: any;
     appUidMapping: {};
     appNameMapping: {};
     marketplaceApps: any[];
@@ -42,10 +42,12 @@ declare class ImportMarketplaceApps {
     getAppName(name: any, appSuffix?: number): any;
     /**
      * @method installApps
-     * @param {Object} options
-     * @returns {Void}
+     *
+     * @param {Record<string, any>} app
+     * @param {Record<string, any>[]} installedApps
+     * @returns {Promise<void>}
      */
-    installApps(app: any, installedApps: any): void;
+    installApps(app: Record<string, any>, installedApps: Record<string, any>[]): Promise<void>;
     makeRedirectUrlCall(response: any, appName: any): Promise<void>;
     ifAppAlreadyExist(app: any, currentStackApp: any): Promise<any>;
     confirmToCloseProcess(installation: any): Promise<void>;

package/lib/import/modules-js/marketplace-apps.js

@@ -62,7 +62,7 @@ module.exports = class ImportMarketplaceApps {
             .catch((error) => {
             console.log(error);
         });
-        if (tempStackData && tempStackData.org_uid) {
+        if (tempStackData === null || tempStackData === void 0 ? void 0 : tempStackData.org_uid) {
             this.config.org_uid = tempStackData.org_uid;
         }
     }
@@ -131,25 +131,26 @@ module.exports = class ImportMarketplaceApps {
         });
     }
     async generateUidMapper() {
+        var _a, _b;
         const listOfNewMeta = [];
         const listOfOldMeta = [];
-        const extensionUidMapp = {};
-        const allInstalledApps = await getAllStackSpecificApps(this.developerHubBaseUrl, this.httpClient, this.config);
+        const extensionUidMap = {};
+        const allInstalledApps = (await getAllStackSpecificApps(this.developerHubBaseUrl, this.httpClient, this.config)) || [];
         for (const app of this.marketplaceApps) {
-            listOfOldMeta.push(..._.map(app.ui_location && app.ui_location.locations, 'meta').flat());
+            listOfOldMeta.push(..._.map((_a = app === null || app === void 0 ? void 0 : app.ui_location) === null || _a === void 0 ? void 0 : _a.locations, 'meta').flat());
         }
         for (const app of allInstalledApps) {
-            listOfNewMeta.push(..._.map(app.ui_location && app.ui_location.locations, 'meta').flat());
+            listOfNewMeta.push(..._.map((_b = app === null || app === void 0 ? void 0 : app.ui_location) === null || _b === void 0 ? void 0 : _b.locations, 'meta').flat());
         }
         for (const { extension_uid, name, path, uid, data_type } of _.filter(listOfOldMeta, 'name')) {
             const meta = _.find(listOfNewMeta, { name, path }) ||
                 _.find(listOfNewMeta, { name: this.appNameMapping[name], path }) ||
                 _.find(listOfNewMeta, { name, uid, data_type });
             if (meta) {
-                extensionUidMapp[extension_uid] = meta.extension_uid;
+                extensionUidMap[extension_uid] = meta.extension_uid;
             }
         }
-        return extensionUidMapp;
+        return extensionUidMap;
     }
     /**
      * @method handleAllPrivateAppsCreationProcess
@@ -166,10 +167,10 @@ module.exports = class ImportMarketplaceApps {
         for (let app of privateApps) {
             // NOTE keys can be passed to install new app in the developer hub
             app.manifest = _.pick(app.manifest, ['uid', 'name', 'description', 'icon', 'target_type', 'webhook', 'oauth']);
-            this.appOrginalName = app.manifest.name;
+            this.appOriginalName = app.manifest.name;
             await this.createPrivateApps(Object.assign({ oauth: app.oauth, webhook: app.webhook, ui_location: app.ui_location }, app.manifest));
         }
-        this.appOrginalName = undefined;
+        this.appOriginalName = undefined;
     }
     async getConfirmationToCreateApps(privateApps) {
         if (!this.config.forceStopMarketplaceAppsPrompt) {
@@ -184,7 +185,8 @@ module.exports = class ImportMarketplaceApps {
         }
     }
     async createPrivateApps(app, uidCleaned = false, appSuffix = 1) {
-        let locations = app.ui_location && app.ui_location.locations;
+        var _a;
+        let locations = (_a = app === null || app === void 0 ? void 0 : app.ui_location) === null || _a === void 0 ? void 0 : _a.locations;
         if (!uidCleaned && !_.isEmpty(locations)) {
             app.ui_location.locations = this.updateManifestUILocations(locations, 'uid');
         }
@@ -223,7 +225,7 @@ module.exports = class ImportMarketplaceApps {
             // NOTE new app installation
             log(this.config, `${response.name} app created successfully.!`, 'success');
             this.appUidMapping[app.uid] = response.uid;
-            this.appNameMapping[this.appOrginalName] = response.name;
+            this.appNameMapping[this.appOriginalName] = response.name;
         }
     }
     async handleNameConflict(app, appSuffix) {
@@ -254,8 +256,8 @@ module.exports = class ImportMarketplaceApps {
                         location.meta = _.map(location.meta, (meta) => {
                             if (meta.name) {
                                 const name = `${_.first(_.split(meta.name, '◈'))}◈${appSuffix}`;
-                                if (!this.appNameMapping[this.appOrginalName]) {
-                                    this.appNameMapping[this.appOrginalName] = name;
+                                if (!this.appNameMapping[this.appOriginalName]) {
+                                    this.appNameMapping[this.appOriginalName] = name;
                                 }
                                 meta.name = name;
                             }
@@ -274,8 +276,10 @@ module.exports = class ImportMarketplaceApps {
     }
     /**
      * @method installApps
-     * @param {Object} options
-     * @returns {Void}
+     *
+     * @param {Record<string, any>} app
+     * @param {Record<string, any>[]} installedApps
+     * @returns {Promise<void>}
      */
     async installApps(app, installedApps) {
         let updateParam;

package/lib/import/modules-js/workflows.js

@@ -101,13 +101,13 @@ module.exports = class importWorkflows {
                         .catch(function (error) {
                         self.fails.push(workflow);
                         if (error.errors.name) {
-                            log(self.config, `workflow ${workflow.name} already exist`, 'error');
+                            log(self.config, `workflow '${workflow.name}' already exist`, 'error');
                         }
                         else if (error.errors['workflow_stages.0.users']) {
                             log(self.config, "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.", 'error');
                         }
                         else {
-                            log(self.config, `workflow ${workflow.name} failed.`, 'error');
+                            log(self.config, `Workflow '${workflow.name}' failed.`, 'error');
                         }
                     });
                 }

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

@@ -140,4 +140,5 @@ export default interface DefaultConfig {
     marketplaceAppEncryptionKey: string;
     getEncryptionKeyMaxRetry: number;
     useNewModuleStructure: boolean;
+    createBackupDir?: string;
 }

package/lib/utils/asset-helper.d.ts

@@ -1,4 +1,4 @@
 import Bluebird from 'bluebird';
 import { ImportConfig } from 'src/types';
 export declare const uploadAssetHelper: (config: ImportConfig, req: any, fsPath: string, RETRY?: number) => Bluebird<unknown>;
-export declare const lookupAssets: (data: any, mappedAssetUids: string[], mappedAssetUrls: string[], assetUidMapperPath: string[], installedExtensions: string[]) => any;
+export declare const lookupAssets: (data: Record<string, any>, mappedAssetUids: Record<string, any>, mappedAssetUrls: Record<string, any>, assetUidMapperPath: string, installedExtensions: Record<string, any>[]) => any;

package/lib/utils/backup-handler.js

@@ -3,12 +3,21 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
 const path = tslib_1.__importStar(require("path"));
 const ncp_1 = tslib_1.__importDefault(require("ncp"));
+const index_1 = require("./index");
 function setupBackupDir(importConfig) {
     return new Promise(async (resolve, reject) => {
         if (importConfig.hasOwnProperty('useBackedupDir')) {
             return resolve(importConfig.useBackedupDir);
         }
-        const backupDirPath = path.join(process.cwd(), '_backup_' + Math.floor(Math.random() * 1000));
+        //NOTE: If the backup folder's directory is provided, create it at that location; otherwise, the default path (working directory).
+        let backupDirPath = path.join(process.cwd(), '_backup_' + Math.floor(Math.random() * 1000));
+        if (importConfig.createBackupDir) {
+            if (index_1.fileHelper.fileExistsSync(importConfig.createBackupDir)) {
+                index_1.fileHelper.removeDirSync(importConfig.createBackupDir);
+            }
+            index_1.fileHelper.makeDirectory(importConfig.createBackupDir);
+            backupDirPath = importConfig.createBackupDir;
+        }
         const limit = importConfig.backupConcurrency || 16;
         if (path.isAbsolute(importConfig.contentDir)) {
             return (0, ncp_1.default)(importConfig.contentDir, backupDirPath, { limit }, (error) => {

package/lib/utils/entries-helper.d.ts

@@ -1,4 +1,7 @@
 /**
  * Entries lookup
  */
-export declare const lookupEntries: (data: any, mappedUids: string[], uidMapperPath: string) => any;
+export declare const lookupEntries: (data: any, mappedUids: Record<string, any>, uidMapperPath: string) => any;
+export declare const removeUidsFromJsonRteFields: (entry: Record<string, any>, ctSchema: Record<string, any>[]) => Record<string, any>;
+export declare const removeEntryRefsFromJSONRTE: (entry: Record<string, any>, ctSchema: Record<string, any>[]) => Record<string, any>;
+export declare const restoreJsonRteEntryRefs: (entry: Record<string, any>, sourceStackEntry: any, ctSchema: any, { mappedAssetUids, mappedAssetUrls }: any) => Record<string, any>;