@contentstack/cli-cm-import 1.7.0 → 1.8.0

package/lib/import/modules/entries.js

@@ -0,0 +1,536 @@
+"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 EntriesImport extends base_class_1.default {
+    constructor({ importConfig, stackAPIClient }) {
+        super({ importConfig, stackAPIClient });
+        this.assetUidMapperPath = path.resolve(importConfig.data, 'mapper', 'assets', 'uid-mapping.json');
+        this.assetUrlMapperPath = path.resolve(importConfig.data, 'mapper', 'assets', 'url-mapping.json');
+        this.entriesMapperPath = path.resolve(importConfig.data, 'mapper', 'entries');
+        this.envPath = path.resolve(importConfig.data, 'environments', 'environments.json');
+        this.entriesUIDMapperPath = path.join(this.entriesMapperPath, 'uid-mapping.json');
+        this.uniqueUidMapperPath = path.join(this.entriesMapperPath, 'unique-mapping.json');
+        this.modifiedCTsPath = path.join(this.entriesMapperPath, 'modified-schemas.json');
+        this.marketplaceAppMapperPath = path.join(this.importConfig.data, 'mapper', 'marketplace_apps', 'uid-mapping.json');
+        this.entriesConfig = importConfig.modules.entries;
+        this.entriesPath = path.resolve(importConfig.data, this.entriesConfig.dirName);
+        this.cTsPath = path.resolve(importConfig.data, importConfig.modules['content-types'].dirName);
+        this.localesPath = path.resolve(importConfig.data, importConfig.modules.locales.dirName, importConfig.modules.locales.fileName);
+        this.importConcurrency = this.entriesConfig.importConcurrency || importConfig.importConcurrency;
+        this.entriesUidMapper = {};
+        this.modifiedCTs = [];
+        this.refCTs = [];
+        this.jsonRteCTs = [];
+        this.jsonRteCTsWithRef = [];
+        this.envs = {};
+        this.autoCreatedEntries = [];
+    }
+    async start() {
+        try {
+            this.cTs = utils_1.fsUtil.readFile(path.join(this.cTsPath, 'schema.json'));
+            if (!this.cTs || (0, lodash_1.isEmpty)(this.cTs)) {
+                (0, utils_1.log)(this.importConfig, 'No content type found', 'info');
+                return;
+            }
+            this.installedExtensions = ((await utils_1.fsUtil.readFile(this.marketplaceAppMapperPath)) || { extension_uid: {} }).extension_uid;
+            this.assetUidMapper = utils_1.fsUtil.readFile(this.assetUidMapperPath) || {};
+            this.assetUrlMapper = utils_1.fsUtil.readFile(this.assetUrlMapperPath) || {};
+            utils_1.fsUtil.makeDirectory(this.entriesMapperPath);
+            await this.disableMandatoryCTReferences();
+            this.locales = (0, lodash_1.values)(utils_1.fsUtil.readFile(this.localesPath));
+            this.locales.unshift(this.importConfig.master_locale); // adds master locale to the list
+            //Create Entries
+            const entryRequestOptions = this.populateEntryCreatePayload();
+            for (let entryRequestOption of entryRequestOptions) {
+                await this.createEntries(entryRequestOption);
+            }
+            await utils_1.fileHelper.writeLargeFile(path.join(this.entriesMapperPath, 'uid-mapping.json'), this.entriesUidMapper); // TBD: manages mapper in one file, should find an alternative
+            utils_1.fsUtil.writeFile(path.join(this.entriesMapperPath, 'failed-entries.json'), this.failedEntries);
+            // Update entries with references
+            const entryUpdateRequestOptions = this.populateEntryUpdatePayload();
+            for (let entryUpdateRequestOption of entryUpdateRequestOptions) {
+                await this.updateEntriesWithReferences(entryUpdateRequestOption).catch((error) => {
+                    (0, utils_1.log)(this.importConfig, `Error while updating entries references of ${entryUpdateRequestOption.cTUid} in locale ${entryUpdateRequestOption.locale}`, 'error');
+                    (0, utils_1.log)(this.importConfig, (0, utils_1.formatError)(error), 'error');
+                });
+            }
+            utils_1.fsUtil.writeFile(path.join(this.entriesMapperPath, 'failed-entries.json'), this.failedEntries);
+            (0, utils_1.log)(this.importConfig, 'Restoring content type changes', 'info');
+            await this.enableMandatoryCTReferences().catch((error) => {
+                (0, utils_1.log)(this.importConfig, `Error while updating content type references ${(0, utils_1.formatError)(error)}`, 'error');
+            });
+            if (this.autoCreatedEntries.length > 0) {
+                (0, utils_1.log)(this.importConfig, 'Removing entries from master language which got created by default', 'info');
+                await this.removeAutoCreatedEntries().catch((error) => {
+                    (0, utils_1.log)(this.importConfig, `Error while removing auto created entries in master locale ${(0, utils_1.formatError)(error)}`, 'error');
+                });
+            }
+            // Update field rule of content types which are got removed earlier
+            (0, utils_1.log)(this.importConfig, 'Updating the field rules of content type', 'info');
+            await this.updateFieldRules().catch((error) => {
+                (0, utils_1.log)(this.importConfig, `Error while updating field rules of content type ${(0, utils_1.formatError)(error)}`, 'error');
+            });
+            (0, utils_1.log)(this.importConfig, 'Entries imported successfully', 'success');
+            // Publishing entries
+            if (this.importConfig.entriesPublish) {
+                (0, utils_1.log)(this.importConfig, 'Publishing entries', 'info');
+                this.envs = utils_1.fileHelper.readFileSync(this.envPath);
+                for (let entryRequestOption of entryRequestOptions) {
+                    await this.publishEntries(entryRequestOption).catch((error) => {
+                        (0, utils_1.log)(this.importConfig, `Error in publishing entries of ${entryRequestOption.cTUid} in locale ${entryRequestOption.locale} ${(0, utils_1.formatError)(error)}`, 'error');
+                    });
+                }
+                (0, utils_1.log)(this.importConfig, 'All the entries have been published successfully', 'success');
+            }
+        }
+        catch (error) {
+            (0, utils_1.log)(this.importConfig, (0, utils_1.formatError)(error), 'error');
+            throw new Error('Error while importing entries');
+        }
+    }
+    async disableMandatoryCTReferences() {
+        const onSuccess = ({ response: contentType, apiData: { uid } }) => {
+            (0, utils_1.log)(this.importConfig, `${uid} content type references removed temporarily`, 'success');
+        };
+        const onReject = ({ error, apiData: { uid } }) => {
+            (0, utils_1.log)(this.importConfig, (0, utils_1.formatError)(error), 'error');
+            throw new Error(`${uid} content type references removal failed`);
+        };
+        return await this.makeConcurrentCall({
+            processName: 'Update content types (removing mandatory references temporarily)',
+            apiContent: this.cTs,
+            apiParams: {
+                serializeData: this.serializeUpdateCTs.bind(this),
+                reject: onReject.bind(this),
+                resolve: onSuccess.bind(this),
+                entity: 'update-cts',
+                includeParamOnCompletion: true,
+            },
+            concurrencyLimit: this.importConcurrency,
+        }).then(() => {
+            utils_1.fsUtil.writeFile(this.modifiedCTsPath, this.modifiedCTs);
+        });
+    }
+    /**
+     * @method serializeUpdateCTs
+     * @param {ApiOptions} apiOptions ApiOptions
+     * @returns {ApiOptions} ApiOptions
+     */
+    serializeUpdateCTs(apiOptions) {
+        const { apiData: contentType } = apiOptions;
+        if (contentType.field_rules) {
+            delete contentType.field_rules;
+        }
+        const flag = {
+            suppressed: false,
+            references: false,
+            jsonRte: false,
+            jsonRteEmbeddedEntries: false,
+        };
+        (0, utils_1.suppressSchemaReference)(contentType.schema, flag);
+        // Check if suppress modified flag
+        if (flag.suppressed) {
+            this.modifiedCTs.push((0, lodash_1.find)(this.cTs, { uid: contentType.uid }));
+        }
+        else {
+            // Note: Skips the content type from update if no reference found
+            apiOptions.additionalInfo = { skip: true };
+            return apiOptions;
+        }
+        if (flag.references) {
+            this.refCTs.push(contentType.uid);
+        }
+        if (flag.jsonRte) {
+            this.jsonRteCTs.push(contentType.uid);
+            if (flag.jsonRteEmbeddedEntries) {
+                this.jsonRteCTsWithRef.push(contentType.uid);
+                if (this.refCTs.indexOf(contentType.uid) === -1) {
+                    this.refCTs.push(contentType.uid);
+                }
+            }
+        }
+        (0, utils_1.lookupExtension)(this.importConfig, contentType.schema, this.importConfig.preserveStackVersion, this.installedExtensions);
+        const contentTypePayload = this.stack.contentType(contentType.uid);
+        Object.assign(contentTypePayload, (0, lodash_1.cloneDeep)(contentType));
+        apiOptions.apiData = contentTypePayload;
+        return apiOptions;
+    }
+    populateEntryCreatePayload() {
+        const requestOptions = [];
+        for (let locale of this.locales) {
+            for (let contentType of this.cTs) {
+                requestOptions.push({
+                    cTUid: contentType.uid,
+                    locale: locale.code,
+                });
+            }
+        }
+        return requestOptions;
+    }
+    async createEntries({ cTUid, locale }) {
+        var _a, _b;
+        const processName = 'Create Entries';
+        const indexFileName = 'index.json';
+        const basePath = path.join(this.entriesPath, cTUid, locale);
+        const fs = new cli_utilities_1.FsUtility({ basePath, indexFileName });
+        const indexer = fs.indexFileContent;
+        const indexerCount = (0, lodash_1.values)(indexer).length;
+        if (indexerCount === 0) {
+            return Promise.resolve();
+        }
+        (0, utils_1.log)(this.importConfig, `Starting to create entries for ${cTUid} in locale ${locale}`, 'info');
+        const isMasterLocale = locale === ((_b = (_a = this.importConfig) === null || _a === void 0 ? void 0 : _a.master_locale) === null || _b === void 0 ? void 0 : _b.code);
+        // Write created entries
+        const entriesCreateFileHelper = new cli_utilities_1.FsUtility({
+            moduleName: 'created-entries',
+            indexFileName: 'index.json',
+            basePath: path.join(this.entriesMapperPath, cTUid, locale),
+            chunkFileSize: this.entriesConfig.chunkFileSize,
+            keepMetadata: false,
+            omitKeys: this.entriesConfig.invalidKeys,
+        });
+        const contentType = (0, lodash_1.find)(this.cTs, { uid: cTUid });
+        const onSuccess = ({ response, apiData: entry, additionalInfo: { entryFileName } }) => {
+            (0, utils_1.log)(this.importConfig, `Created entry: '${entry.title}' of content type ${cTUid} in locale ${locale}`, 'info');
+            this.entriesUidMapper[entry.uid] = response.uid;
+            entry.sourceEntryFilePath = path.join(basePath, entryFileName); // stores source file path temporarily
+            entry.entryOldUid = entry.uid; // stores old uid temporarily
+            if (!isMasterLocale) {
+                this.autoCreatedEntries.push({ cTUid, locale, entryUid: response.uid });
+            }
+            entriesCreateFileHelper.writeIntoFile({ [response.uid]: entry }, { mapKeyVal: true });
+        };
+        const onReject = ({ error, apiData: { uid, title } }) => {
+            (0, utils_1.log)(this.importConfig, `${title} entry of content type ${cTUid} in locale ${locale} failed to create`, 'error');
+            (0, utils_1.log)(this.importConfig, (0, utils_1.formatError)(error), 'error');
+            this.failedEntries.push({ content_type: cTUid, locale, entry: { uid, title } });
+        };
+        for (const index in indexer) {
+            const chunk = await fs.readChunkFiles.next().catch((error) => {
+                (0, utils_1.log)(this.importConfig, (0, utils_1.formatError)(error), 'error');
+            });
+            if (chunk) {
+                let apiContent = (0, lodash_1.values)(chunk);
+                await this.makeConcurrentCall({
+                    apiContent,
+                    processName,
+                    indexerCount,
+                    currentIndexer: +index,
+                    apiParams: {
+                        reject: onReject,
+                        resolve: onSuccess,
+                        entity: 'create-entries',
+                        includeParamOnCompletion: true,
+                        serializeData: this.serializeEntries.bind(this),
+                        additionalInfo: { contentType, locale, cTUid, entryFileName: indexer[index] },
+                    },
+                    concurrencyLimit: this.importConcurrency,
+                }).then(() => {
+                    entriesCreateFileHelper === null || entriesCreateFileHelper === void 0 ? void 0 : entriesCreateFileHelper.completeFile(true);
+                    (0, utils_1.log)(this.importConfig, `Created entries for content type ${cTUid} in locale ${locale}`, 'success');
+                });
+            }
+        }
+    }
+    /**
+     * @method serializeEntries
+     * @param {ApiOptions} apiOptions ApiOptions
+     * @returns {ApiOptions} ApiOptions
+     */
+    serializeEntries(apiOptions) {
+        let { apiData: entry, additionalInfo: { cTUid, locale, contentType }, } = apiOptions;
+        if (this.jsonRteCTs.indexOf(cTUid) > -1) {
+            entry = (0, utils_1.removeUidsFromJsonRteFields)(entry, contentType.schema);
+        }
+        // remove entry references from json-rte fields
+        if (this.jsonRteCTsWithRef.indexOf(cTUid) > -1) {
+            entry = (0, utils_1.removeEntryRefsFromJSONRTE)(entry, contentType.schema);
+        }
+        // will replace all old asset uid/urls with new ones
+        entry = (0, utils_1.lookupAssets)({
+            content_type: contentType,
+            entry: entry,
+        }, this.assetUidMapper, this.assetUrlMapper, path.join(this.entriesPath, cTUid), this.installedExtensions);
+        delete entry.publish_details;
+        apiOptions.apiData = entry;
+        return apiOptions;
+    }
+    populateEntryUpdatePayload() {
+        const requestOptions = [];
+        for (let locale of this.locales) {
+            for (let cTUid of this.refCTs) {
+                requestOptions.push({
+                    cTUid,
+                    locale: locale.code,
+                });
+            }
+        }
+        return requestOptions;
+    }
+    async updateEntriesWithReferences({ cTUid, locale }) {
+        const processName = 'Update Entries';
+        const indexFileName = 'index.json';
+        const basePath = path.join(this.entriesMapperPath, cTUid, locale);
+        const fs = new cli_utilities_1.FsUtility({ basePath, indexFileName });
+        const indexer = fs.indexFileContent;
+        const indexerCount = (0, lodash_1.values)(indexer).length;
+        if (indexerCount === 0) {
+            return Promise.resolve();
+        }
+        (0, utils_1.log)(this.importConfig, `Starting to update entries with references for ${cTUid} in locale ${locale}`, 'info');
+        const contentType = (0, lodash_1.find)(this.cTs, { uid: cTUid });
+        const onSuccess = ({ response, apiData: { uid, url, title } }) => {
+            (0, utils_1.log)(this.importConfig, `Updated entry: '${title}' of content type ${cTUid} in locale ${locale}`, 'info');
+        };
+        const onReject = ({ error, apiData: { uid, title } }) => {
+            (0, utils_1.log)(this.importConfig, `${title} entry of content type ${cTUid} in locale ${locale} failed to update`, 'error');
+            (0, utils_1.log)(this.importConfig, (0, utils_1.formatError)(error), 'error');
+            this.failedEntries.push({ content_type: cTUid, locale, entry: { uid: this.entriesUidMapper[uid], title } });
+        };
+        for (const index in indexer) {
+            const chunk = await fs.readChunkFiles.next().catch((error) => {
+                (0, utils_1.log)(this.importConfig, (0, utils_1.formatError)(error), 'error');
+            });
+            if (chunk) {
+                let apiContent = (0, lodash_1.values)(chunk);
+                await this.makeConcurrentCall({
+                    apiContent,
+                    processName,
+                    indexerCount,
+                    currentIndexer: +index,
+                    apiParams: {
+                        reject: onReject,
+                        resolve: onSuccess,
+                        entity: 'update-entries',
+                        includeParamOnCompletion: true,
+                        serializeData: this.serializeUpdateEntries.bind(this),
+                        additionalInfo: { contentType, locale, cTUid },
+                    },
+                    concurrencyLimit: this.importConcurrency,
+                }).then(() => {
+                    (0, utils_1.log)(this.importConfig, `Updated entries for content type ${cTUid} in locale ${locale}`, 'success');
+                });
+            }
+        }
+    }
+    /**
+     * @method serializeUpdateEntries
+     * @param {ApiOptions} apiOptions ApiOptions
+     * @returns {ApiOptions} ApiOptions
+     */
+    serializeUpdateEntries(apiOptions) {
+        let { apiData: entry, additionalInfo: { cTUid, locale, contentType }, } = apiOptions;
+        const sourceEntryFilePath = entry.sourceEntryFilePath;
+        const sourceEntry = (utils_1.fsUtil.readFile(sourceEntryFilePath) || {})[entry.entryOldUid];
+        // Removing temp values
+        delete entry.sourceEntryFilePath;
+        delete entry.entryOldUid;
+        if (this.jsonRteCTs.indexOf(cTUid) > -1) {
+            // the entries stored in eSuccessFilePath, have the same uids as the entries from source data
+            entry = (0, utils_1.restoreJsonRteEntryRefs)(entry, sourceEntry, contentType.schema, {
+                mappedAssetUids: this.assetUidMapper,
+                mappedAssetUrls: this.assetUrlMapper,
+            });
+        }
+        entry = (0, utils_1.lookupEntries)({
+            content_type: contentType,
+            entry,
+        }, this.entriesUidMapper, path.join(this.entriesMapperPath, cTUid, locale));
+        const entryResponse = this.stack.contentType(contentType.uid).entry(this.entriesUidMapper[entry.uid]);
+        Object.assign(entryResponse, (0, lodash_1.cloneDeep)(entry));
+        delete entryResponse.publish_details;
+        apiOptions.apiData = entryResponse;
+        return apiOptions;
+    }
+    async enableMandatoryCTReferences() {
+        const onSuccess = ({ response: contentType, apiData: { uid } }) => {
+            (0, utils_1.log)(this.importConfig, `${uid} content type references updated`, 'success');
+        };
+        const onReject = ({ error, apiData: { uid } }) => {
+            (0, utils_1.log)(this.importConfig, (0, utils_1.formatError)(error), 'error');
+            throw new Error(`Failed to update references of content type ${uid}`);
+        };
+        return await this.makeConcurrentCall({
+            processName: 'Update content type references',
+            apiContent: this.modifiedCTs,
+            apiParams: {
+                serializeData: this.serializeUpdateCTsWithRef.bind(this),
+                reject: onReject.bind(this),
+                resolve: onSuccess.bind(this),
+                entity: 'update-cts',
+                includeParamOnCompletion: true,
+            },
+            concurrencyLimit: this.importConcurrency,
+        });
+    }
+    /**
+     * @method serializeUpdateCTsWithRef
+     * @param {ApiOptions} apiOptions ApiOptions
+     * @returns {ApiOptions} ApiOptions
+     */
+    serializeUpdateCTsWithRef(apiOptions) {
+        const { apiData: contentType } = apiOptions;
+        if (contentType.field_rules) {
+            delete contentType.field_rules;
+        }
+        (0, utils_1.lookupExtension)(this.importConfig, contentType.schema, this.importConfig.preserveStackVersion, this.installedExtensions);
+        const contentTypePayload = this.stack.contentType(contentType.uid);
+        Object.assign(contentTypePayload, (0, lodash_1.cloneDeep)(contentType));
+        apiOptions.apiData = contentTypePayload;
+        return apiOptions;
+    }
+    async removeAutoCreatedEntries() {
+        const onSuccess = ({ response, apiData: { entryUid } }) => {
+            (0, utils_1.log)(this.importConfig, `Auto created entry in master locale removed - entry uid ${entryUid} `, 'success');
+        };
+        const onReject = ({ error, apiData: { entryUid } }) => {
+            (0, utils_1.log)(this.importConfig, `Failed to remove auto created entry in master locale - entry uid ${entryUid} \n ${(0, utils_1.formatError)(error)}`, 'error');
+        };
+        return await this.makeConcurrentCall({
+            processName: 'Remove auto created entry in master locale',
+            apiContent: this.autoCreatedEntries,
+            apiParams: {
+                reject: onReject.bind(this),
+                resolve: onSuccess.bind(this),
+                entity: 'delete-entries',
+                includeParamOnCompletion: true,
+            },
+            concurrencyLimit: this.importConcurrency,
+        });
+    }
+    async updateFieldRules() {
+        let cTsWithFieldRules = utils_1.fsUtil.readFile(path.join(this.cTsPath + '/field_rules_uid.json'));
+        if (!cTsWithFieldRules || (cTsWithFieldRules === null || cTsWithFieldRules === void 0 ? void 0 : cTsWithFieldRules.length) === 0) {
+            return;
+        }
+        for (let cTUid of cTsWithFieldRules) {
+            const contentType = (0, lodash_1.find)(this.cTs, { uid: cTUid });
+            if (contentType.field_rules) {
+                let fieldRuleLength = contentType.field_rules.length;
+                for (let k = 0; k < fieldRuleLength; k++) {
+                    let fieldRuleConditionLength = contentType.field_rules[k].conditions.length;
+                    for (let i = 0; i < fieldRuleConditionLength; i++) {
+                        if (contentType.field_rules[k].conditions[i].operand_field === 'reference') {
+                            let fieldRulesValue = contentType.field_rules[k].conditions[i].value;
+                            let fieldRulesArray = fieldRulesValue.split('.');
+                            let updatedValue = [];
+                            for (const element of fieldRulesArray) {
+                                let splittedFieldRulesValue = element;
+                                if (this.entriesUidMapper.hasOwnProperty(splittedFieldRulesValue)) {
+                                    updatedValue.push(this.entriesUidMapper[splittedFieldRulesValue]);
+                                }
+                                else {
+                                    updatedValue.push(element);
+                                }
+                            }
+                            contentType.field_rules[k].conditions[i].value = updatedValue.join('.');
+                        }
+                    }
+                }
+                const contentTypeResponse = await this.stack
+                    .contentType(contentType.uid)
+                    .fetch()
+                    .catch((error) => {
+                    (0, utils_1.log)(this.importConfig, `failed to update the field rules of ${cTUid} ${(0, utils_1.formatError)(error)}`, 'error');
+                });
+                if (!contentTypeResponse) {
+                    continue;
+                }
+                contentTypeResponse.field_rules = contentType.field_rules;
+                await contentTypeResponse.update().catch((error) => {
+                    (0, utils_1.log)(this.importConfig, `failed to update the field rules of ${cTUid} ${(0, utils_1.formatError)(error)}`, 'error');
+                });
+                (0, utils_1.log)(this.importConfig, `Updated the field rules of ${cTUid}`, 'info');
+            }
+            else {
+                (0, utils_1.log)(this.importConfig, `No field rules found in content type ${cTUid} to update`, 'error');
+            }
+        }
+    }
+    async publishEntries({ cTUid, locale }) {
+        const processName = 'Publish Entries';
+        const indexFileName = 'index.json';
+        const basePath = path.join(this.entriesPath, cTUid, locale);
+        const fs = new cli_utilities_1.FsUtility({ basePath, indexFileName });
+        const indexer = fs.indexFileContent;
+        const indexerCount = (0, lodash_1.values)(indexer).length;
+        const contentType = (0, lodash_1.find)(this.cTs, { uid: cTUid });
+        if (indexerCount === 0) {
+            return Promise.resolve();
+        }
+        (0, utils_1.log)(this.importConfig, `Starting publish entries for ${cTUid} in locale ${locale}`, 'info');
+        const onSuccess = ({ response, apiData: { environments }, additionalInfo: { entryUid } }) => {
+            (0, utils_1.log)(this.importConfig, `Published entry: '${entryUid}' of content type ${cTUid} and locale ${locale} in ${environments === null || environments === void 0 ? void 0 : environments.join(',')} environments`, 'info');
+        };
+        const onReject = ({ error, apiData, additionalInfo: { entryUid } }) => {
+            (0, utils_1.log)(this.importConfig, `${entryUid} entry of content type ${cTUid} in locale ${locale} failed to publish`, 'error');
+            (0, utils_1.log)(this.importConfig, (0, utils_1.formatError)(error), 'error');
+        };
+        for (const index in indexer) {
+            const chunk = await fs.readChunkFiles.next().catch((error) => {
+                (0, utils_1.log)(this.importConfig, (0, utils_1.formatError)(error), 'error');
+            });
+            if (chunk) {
+                let apiContent = (0, lodash_1.values)(chunk);
+                await this.makeConcurrentCall({
+                    apiContent,
+                    processName,
+                    indexerCount,
+                    currentIndexer: +index,
+                    apiParams: {
+                        reject: onReject,
+                        resolve: onSuccess,
+                        entity: 'publish-entries',
+                        includeParamOnCompletion: true,
+                        serializeData: this.serializePublishEntries.bind(this),
+                        additionalInfo: { contentType, locale, cTUid },
+                    },
+                    concurrencyLimit: this.importConcurrency,
+                }).then(() => {
+                    (0, utils_1.log)(this.importConfig, `Published entries for content type ${cTUid} in locale ${locale}`, 'success');
+                });
+            }
+        }
+    }
+    /**
+     * @method serializeEntries
+     * @param {ApiOptions} apiOptions ApiOptions
+     * @returns {ApiOptions} ApiOptions
+     */
+    serializePublishEntries(apiOptions) {
+        let { apiData: entry, additionalInfo } = apiOptions;
+        additionalInfo.entryUid = this.entriesUidMapper[entry.uid];
+        const requestObject = {
+            environments: [],
+            locales: [],
+        };
+        if (entry.publish_details && entry.publish_details.length > 0) {
+            (0, lodash_1.forEach)(entry.publish_details, (pubObject) => {
+                if (this.envs.hasOwnProperty(pubObject.environment) &&
+                    (0, lodash_1.indexOf)(requestObject.environments, this.envs[pubObject.environment].name) === -1) {
+                    requestObject.environments.push(this.envs[pubObject.environment].name);
+                }
+                if (pubObject.locale && (0, lodash_1.indexOf)(requestObject.locales, pubObject.locale) === -1) {
+                    requestObject.locales.push(pubObject.locale);
+                }
+            });
+        }
+        else {
+            additionalInfo.skip = true;
+        }
+        apiOptions.apiData = requestObject;
+        return apiOptions;
+    }
+}
+exports.default = EntriesImport;

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

@@ -12,7 +12,7 @@ export default class ImportMarketplaceApps extends BaseClass {
     private appUidMapping;
     private installationUidMapping;
     private installedApps;
-    private appOrginalName;
+    private appOriginalName;
     developerHubBaseUrl: string;
     sdkClient: ContentstackClient;
     nodeCrypto: NodeCrypto;
@@ -40,7 +40,10 @@ export default class ImportMarketplaceApps extends BaseClass {
     appCreationCallback(app: any, response: any, appSuffix: number): Promise<any>;
     /**
      * @method installApps
-     * @returns {Void}
+     *
+     * @param {Record<string, any>} app
+     * @param {Record<string, any>[]} installedApps
+     * @returns {Promise<void>}
      */
     installApps(app: any): Promise<void>;
     /**