@contentstack/cli-cm-import 1.5.11 → 1.7.0

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

@@ -0,0 +1,415 @@
+/*!
+ * Contentstack Import
+ * Copyright (c) 2019 Contentstack LLC
+ * MIT Licensed
+ */
+const fs = require('fs');
+const _ = require('lodash');
+const path = require('path');
+const chalk = require('chalk');
+const mkdirp = require('mkdirp');
+const Promise = require('bluebird');
+let { default: config } = require('../../config');
+const { fileHelper, log, uploadAssetHelper } = require('../../utils');
+module.exports = class ImportAssets {
+    constructor(importConfig, stackAPIClient) {
+        this.fails = [];
+        this.uidMapping = {};
+        this.urlMapping = {};
+        this.assetBucket = [];
+        this.folderBucket = [];
+        this.folderDetails = [];
+        this.mappedFolderUids = {};
+        this.config = _.merge(config, importConfig);
+        this.stackAPIClient = stackAPIClient;
+        this.assetConfig = config.modules['assets-old'];
+        this.assetBatchLimit =
+            this.assetConfig.hasOwnProperty('assetBatchLimit') && typeof this.assetConfig.assetBatchLimit === 'number'
+                ? this.assetConfig.assetBatchLimit
+                : 2;
+    }
+    start() {
+        let self = this;
+        log(self.config, 'Migrating assets', 'success');
+        this.assetsFolderPath = path.join(this.config.data, this.assetConfig.dirName);
+        this.mapperDirPath = path.resolve(this.config.data, 'mapper', 'assets');
+        this.environmentPath = path.resolve(this.config.data, 'environments', 'environments.json');
+        this.uidMapperPath = path.join(this.mapperDirPath, 'uid-mapping.json');
+        this.urlMapperPath = path.join(this.mapperDirPath, 'url-mapping.json');
+        this.failsPath = path.join(this.mapperDirPath, 'fail.json');
+        this.assets = fileHelper.readFileSync(path.join(this.assetsFolderPath, this.assetConfig.fileName));
+        this.environment = fileHelper.readFileSync(this.environmentPath);
+        if (fs.existsSync(this.uidMapperPath)) {
+            this.uidMapping = fileHelper.readFileSync(this.uidMapperPath);
+        }
+        if (fs.existsSync(this.urlMapperPath)) {
+            this.urlMapping = fileHelper.readFileSync(this.urlMapperPath);
+        }
+        mkdirp.sync(this.mapperDirPath);
+        return new Promise(function (resolve, reject) {
+            if (self.assets === undefined || _.isEmpty(self.assets)) {
+                log(self.config, 'No Assets Found', 'success');
+                return resolve({ empty: true });
+            }
+            let batches = [];
+            let assetUids = Object.keys(self.assets);
+            for (let i = 0; i < assetUids.length; i += self.assetBatchLimit) {
+                batches.push(assetUids.slice(i, i + self.assetBatchLimit));
+            }
+            return self
+                .importFolders()
+                .then(function () {
+                return Promise.map(batches, async function (batch, index) {
+                    return Promise.map(batch, function (assetUid) {
+                        if (self.uidMapping.hasOwnProperty(assetUid)) {
+                            log(self.config, 'Skipping upload of asset: ' + assetUid + '. Its mapped to: ' + self.uidMapping[assetUid], 'success');
+                            // the asset has been already imported
+                            return void 0;
+                        }
+                        let currentAssetFolderPath = path.join(self.assetsFolderPath, assetUid);
+                        if (fs.existsSync(currentAssetFolderPath)) {
+                            // if this is true, means, the exported asset data is versioned
+                            // hence, upload each asset with its version
+                            if (self.config.versioning) {
+                                return self.uploadVersionedAssets(assetUid, currentAssetFolderPath).catch(function (error) {
+                                    log(self.config, 'Asset upload failed \n' + error, 'error');
+                                });
+                            }
+                            let uidContainer = {};
+                            let urlContainer = {};
+                            let assetPath = path.resolve(currentAssetFolderPath, self.assets[assetUid].filename);
+                            if (self.assets[assetUid].parent_uid && typeof self.assets[assetUid].parent_uid === 'string') {
+                                if (self.mappedFolderUids.hasOwnProperty(self.assets[assetUid].parent_uid)) {
+                                    self.assets[assetUid].parent_uid = self.mappedFolderUids[self.assets[assetUid].parent_uid];
+                                }
+                                else {
+                                    log(self.config, `'${self.assets[assetUid].parent_uid}' parent_uid was not found! Thus, setting it as 'null'`, 'error');
+                                }
+                            }
+                            return self
+                                .uploadAsset(assetPath, self.assets[assetUid], uidContainer, urlContainer)
+                                .then(async function () {
+                                self.uidMapping[assetUid] = uidContainer[assetUid];
+                                self.urlMapping[self.assets[assetUid].url] = urlContainer[self.assets[assetUid].url];
+                                if (self.config.entriesPublish && self.assets[assetUid].publish_details.length > 0) {
+                                    let assetsUid = uidContainer[assetUid];
+                                    try {
+                                        return await self.publish(assetsUid, self.assets[assetUid]);
+                                    }
+                                    catch (error) {
+                                        return error;
+                                    }
+                                }
+                                // assetUid has been successfully uploaded
+                                // log them onto /mapper/assets/success.json
+                            })
+                                .catch(function (error) {
+                                log(self.config, 'Asset upload failed \n' + error, 'error');
+                                return error;
+                                // asset failed to upload
+                                // log them onto /mapper/assets/fail.json
+                            });
+                        }
+                        log(self.config, `'${currentAssetFolderPath}' does not exist!`, 'error');
+                    }, { concurrency: self.assetConfig.assetBatchLimit }).then(function () {
+                        fileHelper.writeFileSync(self.uidMapperPath, self.uidMapping);
+                        fileHelper.writeFileSync(self.urlMapperPath, self.urlMapping);
+                        // completed uploading assets
+                        log(self.config, 'Completed asset import of batch no: ' + (index + 1), 'success');
+                        return index + 1;
+                        // TODO: if there are failures, retry
+                    });
+                }, { concurrency: 1 })
+                    .then(function () {
+                    let numberOfSuccessfulAssetUploads = Object.keys(self.uidMapping).length;
+                    if (numberOfSuccessfulAssetUploads > 0) {
+                        log(self.config, chalk.green(numberOfSuccessfulAssetUploads + ' assets uploaded successfully!'), 'success');
+                    }
+                    // TODO: if there are failures, retry
+                    return resolve();
+                })
+                    .catch(function (error) {
+                    log(self.config, error, 'error');
+                    return reject(error);
+                });
+            })
+                .catch(function (error) {
+                log(self.config, error, 'error');
+                return reject(error);
+            });
+        });
+    }
+    uploadVersionedAssets(uid, assetFolderPath) {
+        let self = this;
+        return new Promise(function (resolve, reject) {
+            let versionedAssetMetadata = fileHelper.readFileSync(path.join(assetFolderPath, '_contentstack_' + uid + '.json'));
+            // using last version, find asset's parent
+            let lastVersion = versionedAssetMetadata[versionedAssetMetadata.length - 1];
+            if (typeof lastVersion.parent_uid === 'string') {
+                if (self.mappedFolderUids.hasOwnProperty(lastVersion.parent_uid)) {
+                    // update each version of that asset with the last version's parent_uid
+                    versionedAssetMetadata.forEach(function (assetMetadata) {
+                        assetMetadata.parent_uid = self.mappedFolderUids[lastVersion.parent_uid];
+                    });
+                }
+                else {
+                    log(self.config, (lastVersion.parent_uid + " parent_uid was not found! Thus, setting it as 'null'", 'error'));
+                    versionedAssetMetadata.forEach(function (assetMetadata) {
+                        assetMetadata.parent_uid = null;
+                    });
+                }
+            }
+            let counter = 0;
+            let uidContainer = {};
+            let urlContainer = {};
+            let filesStreamed = [];
+            return Promise.map(versionedAssetMetadata, function () {
+                let assetMetadata = versionedAssetMetadata[counter];
+                let assetPath = path.join(assetFolderPath, assetMetadata.filename);
+                if (++counter === 1) {
+                    return self
+                        .uploadAsset(assetPath, assetMetadata, uidContainer, urlContainer)
+                        .then(function () {
+                        filesStreamed.push(assetMetadata.filename);
+                    })
+                        .catch((error) => {
+                        log(self.config, error, 'error');
+                        reject(error);
+                    });
+                }
+                return self
+                    .updateAsset(assetPath, assetMetadata, filesStreamed, uidContainer, urlContainer)
+                    .then(function () {
+                    filesStreamed.push(assetMetadata.filename);
+                })
+                    .catch((error) => {
+                    log(self.config, error, 'error');
+                });
+            }, { concurrency: self.assetConfig.uploadAssetsConcurrency })
+                .then(function () {
+                self.uidMapping[uid] = uidContainer[uid];
+                for (let url in urlContainer) {
+                    self.urlMapping[url] = urlContainer[url];
+                }
+                // completed uploading all the versions of the asset
+                return resolve();
+            })
+                .catch(function (error) {
+                // failed to upload asset
+                // write it on fail logs, but do not stop the process
+                log(self.config, 'Failed to upload asset\n' + error, 'error');
+                return resolve();
+            });
+        });
+    }
+    updateAsset(assetPath, metadata, filesStreamed, _uidContainer, urlContainer) {
+        const self = this;
+        return new Promise(function (resolve, reject) {
+            let requestOption = {};
+            if (filesStreamed && filesStreamed.indexOf(metadata.filename) !== -1) {
+                log(self.config, 'Skipping re-upload/streaming of ' + metadata.uid + '/' + metadata.filename, 'success');
+                requestOption.formData = {};
+                return resolve();
+            }
+            log(self.config, 'Streaming: ' + metadata.uid + '/' + metadata.filename, 'success');
+            requestOption.formData = {};
+            if (metadata.hasOwnProperty('parent_uid') && typeof metadata.parent_uid === 'string') {
+                requestOption.formData['asset[parent_uid]'] = metadata.parent_uid;
+            }
+            if (metadata.hasOwnProperty('description') && typeof metadata.description === 'string') {
+                requestOption.formData['asset[description]'] = metadata.description;
+            }
+            if (metadata.hasOwnProperty('tags') && Array.isArray(metadata.tags)) {
+                requestOption.formData['asset[tags]'] = metadata.tags;
+            }
+            if (metadata.hasOwnProperty('title') && typeof metadata.title === 'string') {
+                requestOption.formData['asset[title]'] = metadata.title;
+            }
+            return uploadAssetHelper(self.config, requestOption, assetPath)
+                .then(function (response) {
+                urlContainer[metadata.url] = response.url;
+                return resolve();
+            })
+                .catch(function (error) {
+                log(self.config, error, 'error');
+                return reject(error);
+            });
+        });
+    }
+    uploadAsset(assetPath, metadata, uidContainer, urlContainer) {
+        const self = this;
+        return new Promise(function (resolve, reject) {
+            let requestOption = {};
+            if (metadata.hasOwnProperty('parent_uid') && typeof metadata.parent_uid === 'string') {
+                requestOption.parent_uid = metadata.parent_uid;
+            }
+            if (metadata.hasOwnProperty('description') && typeof metadata.description === 'string') {
+                requestOption.description = metadata.description;
+            }
+            // eslint-disable-next-line no-prototype-builtins
+            if (metadata.hasOwnProperty('tags') && Array.isArray(metadata.tags)) {
+                requestOption.tags = metadata.tags;
+            }
+            if (metadata.hasOwnProperty('title') && typeof metadata.title === 'string') {
+                requestOption.title = metadata.title;
+            }
+            return uploadAssetHelper(self.config, requestOption, assetPath)
+                .then(function (response) {
+                uidContainer[metadata.uid] = response.uid;
+                urlContainer[metadata.url] = response.url;
+                return resolve();
+            })
+                .catch(function (error) {
+                log(self.config, error, 'error');
+                return reject(error);
+            });
+        });
+    }
+    importFolders() {
+        let self = this;
+        return new Promise(function (resolve, reject) {
+            let mappedFolderPath = path.resolve(self.config.data, 'mapper', 'assets', 'folder-mapping.json');
+            self.folderDetails = fileHelper.readFileSync(path.resolve(self.assetsFolderPath, 'folders.json'));
+            if (_.isEmpty(self.folderDetails)) {
+                log(self.config, 'No folders were found at: ' + path.join(self.assetsFolderPath, 'folders.json'), 'success');
+                return resolve();
+            }
+            let tree = self.buildTree(_.cloneDeep(self.folderDetails));
+            let createdFolders = {};
+            let createdFolderUids = [];
+            // if a few folders have already been created, skip re-creating them
+            if (fs.existsSync(mappedFolderPath)) {
+                createdFolders = fileHelper.readFileSync(mappedFolderPath);
+                // check if the read file has mapped objects
+                if (_.isPlainObject(createdFolders)) {
+                    createdFolderUids = Object.keys(createdFolders);
+                }
+            }
+            self.buildFolderReqObjs(createdFolderUids, tree, null);
+            let idx = 0;
+            return Promise.map(self.folderBucket, function () {
+                let folder = self.folderBucket[idx];
+                if (createdFolders.hasOwnProperty(folder.json.asset.parent_uid)) {
+                    // replace old uid with new
+                    folder.json.asset.parent_uid = createdFolders[folder.json.asset.parent_uid];
+                }
+                return self.stackAPIClient
+                    .asset()
+                    .folder()
+                    .create(folder.json)
+                    .then((response) => {
+                    log(self.config, "Created folder: '" + folder.json.asset.name + "'", 'success');
+                    // assigning newUid to oldUid
+                    createdFolders[folder.oldUid] = response.uid;
+                    fileHelper.writeFileSync(mappedFolderPath, createdFolders);
+                    idx++;
+                })
+                    .catch(function (err) {
+                    let error = JSON.parse(err.message);
+                    if (error.errors.authorization || error.errors.api_key) {
+                        log(self.config, 'Api_key or management_token is not valid', 'error');
+                        return reject(error);
+                    }
+                    log(self.config, err, 'error');
+                    return error;
+                });
+            }, { concurrency: self.assetConfig.importFoldersConcurrency })
+                .then(function () {
+                self.mappedFolderUids = fileHelper.readFileSync(mappedFolderPath);
+                // completed creating folders
+                return resolve();
+            })
+                .catch(function (error) {
+                log(self.config, error, 'error');
+                return reject(error);
+            });
+        });
+    }
+    buildFolderReqObjs(createdFolderUids, tree, parent_uid) {
+        let self = this;
+        for (let leaf in tree) {
+            // if the folder is already created, skip
+            if (createdFolderUids.indexOf(leaf) !== -1) {
+                continue;
+            }
+            let folderObj = _.find(self.folderDetails, { uid: leaf });
+            let requestOption = {
+                json: {
+                    asset: {
+                        name: folderObj.name,
+                        parent_uid: parent_uid || null,
+                    },
+                },
+                oldUid: leaf,
+            };
+            self.folderBucket.push(requestOption);
+            if (Object.keys(tree[leaf]).length > 0) {
+                self.buildFolderReqObjs(createdFolderUids, tree[leaf], leaf);
+            }
+        }
+    }
+    buildTree(coll) {
+        let tree = {};
+        for (let i = 0; i < coll.length; i++) {
+            if (coll[i].parent_uid === null || !coll[i].hasOwnProperty('parent_uid')) {
+                tree[coll[i].uid] = {};
+                coll.splice(i, 1);
+                i--;
+            }
+        }
+        this.findBranches(tree, _.keys(tree), coll);
+        return tree;
+    }
+    findBranches(tree, branches, coll) {
+        let self = this;
+        _.forEach(branches, (branch) => {
+            for (const element of coll) {
+                if (branch === element.parent_uid) {
+                    let childUid = element.uid;
+                    tree[branch][childUid] = {};
+                    self.findBranches(tree[branch], [childUid], coll);
+                }
+            }
+        });
+    }
+    publish(assetUid, assetObject) {
+        let envId = [];
+        let self = this;
+        let locales = [];
+        let requestObject = { json: { asset: {} } };
+        return new Promise(function (resolve, reject) {
+            _.forEach(assetObject.publish_details, function (pubObject) {
+                if (self.environment.hasOwnProperty(pubObject.environment)) {
+                    envId.push(self.environment[pubObject.environment].name);
+                    let idx = _.indexOf(locales, pubObject.locale);
+                    if (idx === -1) {
+                        locales.push(pubObject.locale);
+                    }
+                }
+            });
+            requestObject.json.asset.environments = envId;
+            requestObject.json.asset.locales = locales;
+            return self.stackAPIClient
+                .asset(assetUid)
+                .publish({ publishDetails: requestObject.json.asset })
+                .then(function () {
+                log(self.config, 'Asset ' + assetUid + ' published successfully', 'success');
+                return resolve();
+            })
+                .catch(function (err) {
+                if (err && err.message) {
+                    let error;
+                    try {
+                        error = JSON.parse(err.message);
+                    }
+                    catch (cError) {
+                        error = { errorMessage: err.message };
+                    }
+                    log(self.config, 'Asset ' + assetUid + ' not published, ' + error.errorMessage, 'error');
+                    return reject(err);
+                }
+                return reject(err);
+            });
+        });
+    }
+};

package/lib/import/modules-js/content-types.d.ts

@@ -0,0 +1,33 @@
+export = ContentTypesImport;
+declare class ContentTypesImport {
+    constructor(importConfig: any, stackAPIClient: any);
+    stackAPIClient: any;
+    importConfig: any;
+    contentTypeConfig: any;
+    globalFieldConfig: any;
+    importConcurrency: any;
+    writeConcurrency: any;
+    contentTypesFolderPath: string;
+    mapperFolderPath: string;
+    existingContentTypesPath: string;
+    globalFieldsFolderPath: string;
+    globalFieldMapperFolderPath: string;
+    globalFieldPendingPath: string;
+    ignoredFilesInContentTypesFolder: Map<string, string>;
+    contentTypes: any[];
+    existingContentTypesUIds: any[];
+    titleToUIdMap: Map<any, any>;
+    requestOptions: {
+        json: {};
+    };
+    fieldRules: any[];
+    installedExtensions: any[];
+    globalFields: any[];
+    existingGlobalFields: any[];
+    pendingGlobalFields: any[];
+    start(): Promise<void>;
+    seedContentType(contentType: any): Promise<boolean>;
+    updateContentType(contentType: any): Promise<void>;
+    updateGlobalFields(uid: any): Promise<boolean>;
+    mapUidToTitle(): Promise<void>;
+}

package/lib/import/modules-js/content-types.js

@@ -0,0 +1,176 @@
+const fs = require('fs');
+const path = require('path');
+const chalk = require('chalk');
+const { cloneDeep, find, findIndex } = require('lodash');
+const { fileHelper, log, executeTask, formatError, schemaTemplate, lookupExtension } = require('../../utils');
+class ContentTypesImport {
+    constructor(importConfig, stackAPIClient) {
+        this.stackAPIClient = stackAPIClient;
+        this.importConfig = importConfig;
+        this.contentTypeConfig = importConfig.modules.content_types;
+        this.globalFieldConfig = importConfig.modules.globalfields;
+        this.importConcurrency = this.contentTypeConfig.importConcurrency || this.importConfig.importConcurrency;
+        this.writeConcurrency = this.contentTypeConfig.writeConcurrency || this.importConfig.writeConcurrency;
+        this.contentTypesFolderPath = path.join(this.importConfig.data, this.contentTypeConfig.dirName);
+        this.mapperFolderPath = path.join(this.importConfig.data, 'mapper', 'content_types');
+        this.existingContentTypesPath = path.join(this.mapperFolderPath, 'success.json');
+        this.globalFieldsFolderPath = path.resolve(this.importConfig.data, this.globalFieldConfig.dirName);
+        this.globalFieldMapperFolderPath = path.join(importConfig.data, 'mapper', 'global_fields', 'success.json');
+        this.globalFieldPendingPath = path.join(importConfig.data, 'mapper', 'global_fields', 'pending_global_fields.js');
+        this.ignoredFilesInContentTypesFolder = new Map([
+            ['__master.json', 'true'],
+            ['__priority.json', 'true'],
+            ['schema.json', 'true'],
+            ['.DS_Store', 'true'],
+        ]);
+        this.contentTypes = [];
+        this.existingContentTypesUIds = [];
+        this.titleToUIdMap = new Map();
+        this.requestOptions = {
+            json: {},
+        };
+        this.fieldRules = [];
+        this.installedExtensions = [];
+        this.globalFields = [];
+        this.existingGlobalFields = [];
+        this.pendingGlobalFields = [];
+    }
+    async start() {
+        try {
+            const appMapperPath = path.join(this.importConfig.data, 'mapper', 'marketplace_apps', 'uid-mapping.json');
+            this.installedExtensions = ((await fileHelper.readFileSync(appMapperPath)) || { extension_uid: {} }).extension_uid;
+            // read content types
+            // remove content types already existing
+            if (fs.existsSync(this.existingContentTypesPath)) {
+                this.existingContentTypesUIds = fileHelper.readFileSync(this.existingContentTypesPath) || [];
+                this.existingContentTypesUIds = new Map(this.existingContentTypesUIds.map((id) => [id, 'true']));
+            }
+            const contentTypeFiles = fileHelper.readdirSync(this.contentTypesFolderPath);
+            for (let contentTypeName of contentTypeFiles) {
+                if (!this.ignoredFilesInContentTypesFolder.has(contentTypeName)) {
+                    const contentTypePath = path.join(this.contentTypesFolderPath, contentTypeName);
+                    const contentType = await fileHelper.readFile(contentTypePath);
+                    if (!this.existingContentTypesUIds.length || !this.existingContentTypesUIds.has(contentType.uid)) {
+                        this.contentTypes.push(await fileHelper.readFile(contentTypePath));
+                    }
+                }
+            }
+            // seed content type
+            log(this.importConfig, 'Started to seed content types', 'info');
+            await executeTask(this.contentTypes, this.seedContentType.bind(this), { concurrency: this.importConcurrency });
+            log(this.importConfig, 'Created content types', 'success');
+            log(this.importConfig, 'Started to update content types with references', 'info');
+            await executeTask(this.contentTypes, this.updateContentType.bind(this), { concurrency: this.importConcurrency });
+            log(this.importConfig, 'Updated content types with references', 'success');
+            // global field update
+            this.pendingGlobalFields = fileHelper.readFileSync(this.globalFieldPendingPath);
+            if (Array.isArray(this.pendingGlobalFields) && this.pendingGlobalFields.length > 0) {
+                this.globalFields = fileHelper.readFileSync(path.resolve(this.globalFieldsFolderPath, this.globalFieldConfig.fileName));
+                this.existingGlobalFields = fileHelper.readFileSync(this.globalFieldMapperFolderPath);
+                try {
+                    log(this.importConfig, 'Started to update pending global field with content type references', 'info');
+                    await executeTask(this.pendingGlobalFields, this.updateGlobalFields.bind(this), {
+                        concurrency: this.importConcurrency,
+                    });
+                    log(this.importConfig, 'Updated pending global fields with content type with references', 'success');
+                }
+                catch (error) {
+                    log(this.importConfig, `Failed to updates global fields with content type reference ${formatError(error)}`, 'error');
+                }
+            }
+            // write field rules
+            if (this.fieldRules.length > 0) {
+                try {
+                    await fileHelper.writeFile(path.join(this.contentTypesFolderPath, 'field_rules_uid.json'), this.fieldRules);
+                }
+                catch (error) {
+                    log(this.importConfig, `Failed to write field rules ${formatError(error)}`, 'success');
+                }
+            }
+            log(this.importConfig, chalk.green('Content types imported successfully'), 'success');
+        }
+        catch (error) {
+            let message_content_type = "";
+            if (error.request !== undefined && JSON.parse(error.request.data).content_type !== undefined) {
+                if (JSON.parse(error.request.data).content_type.uid) {
+                    message_content_type =
+                        ' Update the content type with content_type_uid  - ' + JSON.parse(error.request.data).content_type.uid;
+                }
+                else if (JSON.parse(error.request.data).content_type.title) {
+                    message_content_type =
+                        ' Update the content type with content_type_title  - ' + JSON.parse(error.request.data).content_type.title;
+                }
+                error.errorMessage = error.errorMessage + message_content_type;
+            }
+            log(this.importConfig, formatError(error.errorMessage), 'error');
+            log(this.importConfig, formatError(error), 'error');
+            throw new Error('Failed to import content types');
+        }
+    }
+    async seedContentType(contentType) {
+        const body = cloneDeep(schemaTemplate);
+        body.content_type.uid = contentType.uid;
+        body.content_type.title = contentType.title;
+        const requestObject = cloneDeep(this.requestOptions);
+        requestObject.json = body;
+        try {
+            await this.stackAPIClient.contentType().create(requestObject.json);
+        }
+        catch (error) {
+            if (error.errorCode === 115 && (error.errors.uid || error.errors.title)) {
+                // content type uid already exists
+                // _.remove(self.contentTypes, { uid: uid });
+                return true;
+            }
+            throw error;
+        }
+    }
+    async updateContentType(contentType) {
+        if (typeof contentType !== 'object')
+            return;
+        const requestObject = cloneDeep(this.requestOptions);
+        if (contentType.field_rules) {
+            this.fieldRules.push(contentType.uid);
+            delete contentType.field_rules;
+        }
+        lookupExtension(this.importConfig, contentType.schema, this.importConfig.preserveStackVersion, this.installedExtensions);
+        requestObject.json.content_type = contentType;
+        const contentTypeResponse = this.stackAPIClient.contentType(contentType.uid);
+        Object.assign(contentTypeResponse, cloneDeep(contentType));
+        await contentTypeResponse.update();
+        log(this.importConfig, contentType.uid + ' updated with references', 'success');
+    }
+    async updateGlobalFields(uid) {
+        const globalField = find(this.globalFields, { uid });
+        if (globalField) {
+            lookupExtension(this.importConfig, globalField.schema, this.importConfig.preserveStackVersion, this.installedExtensions);
+            let globalFieldObj = this.stackAPIClient.globalField(globalField.uid);
+            Object.assign(globalFieldObj, cloneDeep(globalField));
+            try {
+                const globalFieldResponse = await globalFieldObj.update();
+                const existingGlobalField = findIndex(this.existingGlobalFields, (existingGlobalFieldUId) => {
+                    return globalFieldResponse.uid === existingGlobalFieldUId;
+                });
+                // Improve write the updated global fields once all updates are completed
+                this.existingGlobalFields.splice(existingGlobalField, 1, globalField);
+                await fileHelper.writeFile(this.globalFieldMapperFolderPath, this.existingGlobalFields).catch((error) => {
+                    log(this.importConfig, `failed to write updated the global field ${uid} ${formatError(error)}`);
+                });
+                log(this.importConfig, `Updated the global field ${uid} with content type references `);
+                return true;
+            }
+            catch (error) {
+                log(this.importConfig, `failed to update the global field ${uid} ${formatError(error)}`);
+            }
+        }
+        else {
+            log(this.importConfig, `Global field ${uid} does not exist, and hence failed to update.`);
+        }
+    }
+    async mapUidToTitle() {
+        this.contentTypes.forEach((ct) => {
+            this.titleToUIdMap.set(ct.uid, ct.title);
+        });
+    }
+}
+module.exports = ContentTypesImport;

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

@@ -0,0 +1,15 @@
+export = ImportCustomRoles;
+declare class ImportCustomRoles {
+    constructor(importConfig: any, stackAPIClient: any);
+    fails: any[];
+    labelUids: any[];
+    customRolesUidMapper: {};
+    customRolesConfig: {
+        dirName: string;
+        fileName: string;
+        customRolesLocalesFileName: string;
+    };
+    config: any;
+    stackAPIClient: any;
+    start(): Promise<void>;
+}