@contentstack/cli-cm-import 1.5.11 → 1.6.0

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

@@ -0,0 +1,31 @@
+/*!
+ * Contentstack Import
+ * Copyright (c) 2019 Contentstack LLC
+ * MIT Licensed
+ */
+import { ModuleClassParams } from '../../types';
+import BaseClass from './base-class';
+export default class ImportLocales extends BaseClass {
+    private langMapperPath;
+    private langFolderPath;
+    private langFailsPath;
+    private langSuccessPath;
+    private langUidMapperPath;
+    private languages;
+    private config;
+    private stackAPIClient;
+    private failedLocales;
+    private createdLocales;
+    private langUidMapper;
+    private localeConfig;
+    client: any;
+    private reqConcurrency;
+    private masterLanguage;
+    private masterLanguageConfig;
+    private sourceMasterLanguage;
+    constructor({ importConfig, stackAPIClient }: ModuleClassParams);
+    start(): Promise<any>;
+    checkAndUpdateMasterLocale(): Promise<any>;
+    createLocales(): Promise<any>;
+    updateLocales(): Promise<unknown>;
+}

package/lib/import/modules/locales.js

@@ -0,0 +1,152 @@
+"use strict";
+/* eslint-disable no-prototype-builtins */
+/*!
+ * Contentstack Import
+ * Copyright (c) 2019 Contentstack LLC
+ * MIT Licensed
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const path = tslib_1.__importStar(require("path"));
+const lodash_1 = require("lodash");
+const cli_utilities_1 = require("@contentstack/cli-utilities");
+const utils_1 = require("../../utils");
+const base_class_1 = tslib_1.__importDefault(require("./base-class"));
+class ImportLocales extends base_class_1.default {
+    constructor({ importConfig, stackAPIClient }) {
+        super({ importConfig, stackAPIClient });
+        this.config = importConfig;
+        this.localeConfig = importConfig.modules.locales;
+        this.masterLanguage = importConfig.masterLocale;
+        this.masterLanguageConfig = importConfig.modules.masterLocale;
+        this.stackAPIClient = stackAPIClient;
+        this.languages = [];
+        this.langUidMapper = {};
+        this.createdLocales = [];
+        this.failedLocales = [];
+        this.reqConcurrency = this.localeConfig.writeConcurrency || this.config.writeConcurrency;
+        this.langMapperPath = path.resolve(this.config.data, 'mapper', 'languages');
+        this.langFolderPath = path.resolve(this.config.data, this.localeConfig.dirName);
+        this.langFailsPath = path.resolve(this.config.data, 'mapper', 'languages', 'fails.json');
+        this.langSuccessPath = path.resolve(this.config.data, 'mapper', 'languages', 'success.json');
+        this.langUidMapperPath = path.resolve(this.config.data, 'mapper', 'languages', 'uid-mapper.json');
+    }
+    async start() {
+        /**
+         * read locales
+         * create a mapper dir
+         * read / create a locale uid mapper
+         * update master language details if it same
+         * create locales
+         * update locales
+         */
+        this.languages = utils_1.fsUtil.readFile(path.join(this.langFolderPath, this.localeConfig.fileName));
+        if (!this.languages || (0, lodash_1.isEmpty)(this.languages)) {
+            (0, utils_1.log)(this.config, 'No languages found to import', 'info');
+            return;
+        }
+        this.sourceMasterLanguage = utils_1.fsUtil.readFile(path.join(this.langFolderPath, this.masterLanguageConfig.fileName));
+        await utils_1.fileHelper.makeDirectory(this.langMapperPath);
+        if (utils_1.fileHelper.fileExistsSync(this.langUidMapperPath)) {
+            this.langUidMapper = utils_1.fsUtil.readFile(this.langUidMapperPath) || {};
+        }
+        await this.checkAndUpdateMasterLocale().catch((error) => {
+            (0, utils_1.log)(this.config, (0, utils_1.formatError)(error), 'error');
+        });
+        await this.createLocales().catch((error) => {
+            (0, utils_1.log)(this.config, (0, utils_1.formatError)(error), 'error');
+            Promise.reject('Failed to import locales');
+        });
+        utils_1.fsUtil.writeFile(this.langFailsPath, this.failedLocales);
+        await this.updateLocales().catch((error) => {
+            (0, utils_1.log)(this.config, (0, utils_1.formatError)(error), 'error');
+            Promise.reject('Failed to update locales');
+        });
+        (0, utils_1.log)(this.config, 'Languages have been imported successfully!', 'success');
+    }
+    async checkAndUpdateMasterLocale() {
+        var _a, _b, _c, _d;
+        let sourceMasterLangDetails = (this.sourceMasterLanguage && Object.values(this.sourceMasterLanguage)) || [];
+        if (((_a = sourceMasterLangDetails === null || sourceMasterLangDetails === void 0 ? void 0 : sourceMasterLangDetails[0]) === null || _a === void 0 ? void 0 : _a.code) === ((_b = this.masterLanguage) === null || _b === void 0 ? void 0 : _b.code)) {
+            let masterLangDetails = await this.stackAPIClient
+                .locale(this.masterLanguage['code'])
+                .fetch()
+                .catch((error) => {
+                (0, utils_1.log)(this.config, (0, utils_1.formatError)(error), 'error');
+            });
+            if (((_c = masterLangDetails === null || masterLangDetails === void 0 ? void 0 : masterLangDetails.name) === null || _c === void 0 ? void 0 : _c.toString().toUpperCase()) !==
+                ((_d = sourceMasterLangDetails[0]['name']) === null || _d === void 0 ? void 0 : _d.toString().toUpperCase())) {
+                cli_utilities_1.cliux.print('WARNING!!! The master language name for the source and destination is different.', {
+                    color: 'yellow',
+                });
+                cli_utilities_1.cliux.print(`Old Master language name: ${masterLangDetails['name']}`, { color: 'red' });
+                cli_utilities_1.cliux.print(`New Master language name: ${sourceMasterLangDetails[0]['name']}`, { color: 'green' });
+                const langUpdateConfirmation = await cli_utilities_1.cliux.inquire({
+                    type: 'confirm',
+                    message: 'Are you sure you want to update name of master language?',
+                    name: 'confirmation',
+                });
+                if (langUpdateConfirmation) {
+                    let langUid = sourceMasterLangDetails[0] && sourceMasterLangDetails[0]['uid'];
+                    let sourceMasterLanguage = this.sourceMasterLanguage[langUid];
+                    if (!sourceMasterLanguage) {
+                        (0, utils_1.log)(this.config, `Master language details not found with id ${langUid} to update`, 'warn');
+                    }
+                    const langUpdateRequest = this.stackAPIClient.locale(sourceMasterLanguage.code);
+                    langUpdateRequest.name = sourceMasterLanguage.name;
+                    await langUpdateRequest.update().catch(function (error) {
+                        (0, utils_1.log)(this.config, (0, utils_1.formatError)(error), 'error');
+                    });
+                    (0, utils_1.log)(this.config, 'Master Languages name have been updated successfully!', 'success');
+                }
+            }
+        }
+    }
+    async createLocales() {
+        const onSuccess = ({ response = {}, apiData: { uid, code } = undefined }) => {
+            this.langUidMapper[uid] = response.uid;
+            this.createdLocales.push((0, lodash_1.pick)(response, [...this.localeConfig.requiredKeys]));
+            (0, utils_1.log)(this.importConfig, `Created locale: '${code}'`, 'info');
+            utils_1.fsUtil.writeFile(this.langUidMapperPath, this.langUidMapper);
+        };
+        const onReject = ({ error, apiData: { uid, code } = undefined }) => {
+            (0, utils_1.log)(this.importConfig, `Language '${code}' failed to import`, 'error');
+            (0, utils_1.log)(this.importConfig, (0, utils_1.formatError)(error), 'error');
+            this.failedLocales.push({ uid, code });
+        };
+        return await this.makeConcurrentCall({
+            processName: 'Import locales',
+            apiContent: (0, lodash_1.filter)((0, lodash_1.values)(this.languages), (lang) => lang.code !== this.masterLanguage.code),
+            apiParams: {
+                reject: onReject.bind(this),
+                resolve: onSuccess.bind(this),
+                entity: 'create-locale',
+                includeParamOnCompletion: true,
+            },
+            concurrencyLimit: this.reqConcurrency,
+        });
+    }
+    async updateLocales() {
+        const onSuccess = ({ response = {}, apiData: { uid, code } = undefined }) => {
+            (0, utils_1.log)(this.importConfig, `Updated locale: '${code}'`, 'info');
+            utils_1.fsUtil.writeFile(this.langSuccessPath, this.createdLocales);
+        };
+        const onReject = ({ error, apiData: { uid, code } = undefined }) => {
+            (0, utils_1.log)(this.importConfig, `Language '${code}' failed to update`, 'error');
+            (0, utils_1.log)(this.importConfig, (0, utils_1.formatError)(error), 'error');
+            utils_1.fsUtil.writeFile(this.langFailsPath, this.failedLocales);
+        };
+        return await this.makeConcurrentCall({
+            processName: 'Update locales',
+            apiContent: (0, lodash_1.values)(this.languages),
+            apiParams: {
+                reject: onReject.bind(this),
+                resolve: onSuccess.bind(this),
+                entity: 'update-locale',
+                includeParamOnCompletion: true,
+            },
+            concurrencyLimit: this.reqConcurrency,
+        });
+    }
+}
+exports.default = ImportLocales;

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

@@ -0,0 +1,33 @@
+export = ImportAssets;
+declare class ImportAssets {
+    constructor(importConfig: any, stackAPIClient: any);
+    assets: any;
+    fails: any[];
+    assetConfig: any;
+    mapperDirPath: any;
+    assetBatchLimit: any;
+    uidMapping: {};
+    urlMapping: {};
+    environmentPath: any;
+    assetBucket: any[];
+    assetsFolderPath: any;
+    folderBucket: any[];
+    folderDetails: any[];
+    mappedFolderUids: {};
+    config: any;
+    stackAPIClient: any;
+    start(): Promise<any>;
+    uidMapperPath: string;
+    urlMapperPath: string;
+    failsPath: string;
+    environment: any;
+    uploadVersionedAssets(uid: any, assetFolderPath: any): Promise<any>;
+    updateAsset(assetPath: any, metadata: any, filesStreamed: any, _uidContainer: any, urlContainer: any): Promise<any>;
+    uploadAsset(assetPath: any, metadata: any, uidContainer: any, urlContainer: any): Promise<any>;
+    importFolders(): Promise<any>;
+    buildFolderReqObjs(createdFolderUids: any, tree: any, parent_uid: any): void;
+    buildTree(coll: any): {};
+    findBranches(tree: any, branches: any, coll: any): void;
+    publish(assetUid: any, assetObject: any): Promise<any>;
+}
+import Promise = require("bluebird");

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>;
+}