@contentstack/cli-cm-import 1.5.10 → 1.6.0

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

@@ -0,0 +1,196 @@
+/* eslint-disable no-prototype-builtins */
+/*!
+ * Contentstack Import
+ * Copyright (c) 2019 Contentstack LLC
+ * MIT Licensed
+ */
+let fs = require('fs');
+let path = require('path');
+let chalk = require('chalk');
+let mkdirp = require('mkdirp');
+let Promise = require('bluebird');
+let { isEmpty, merge, cloneDeep } = require('lodash');
+const { cliux } = require('@contentstack/cli-utilities');
+let { default: config } = require('../../config');
+const { fileHelper, log, formatError } = require('../../utils');
+module.exports = class ImportLanguages {
+    constructor(importConfig, stackAPIClient) {
+        var _a;
+        this.config = merge(config, importConfig);
+        this.stackAPIClient = stackAPIClient;
+        this.fails = [];
+        this.success = [];
+        this.langUidMapper = {};
+        this.masterLanguage = (_a = importConfig.master_locale) === null || _a === void 0 ? void 0 : _a.code;
+        this.langConfig = importConfig.modules.locales;
+        this.sourceMasterLangConfig = config.modules.masterLocale;
+        this.reqConcurrency = importConfig.concurrency || importConfig.fetchConcurrency || 1;
+    }
+    start() {
+        log(this.config, 'Migrating languages', 'success');
+        const self = this;
+        let langMapperPath = path.resolve(this.config.data, 'mapper', 'languages');
+        let langFolderPath = path.resolve(this.config.data, this.langConfig.dirName);
+        let langFailsPath = path.resolve(this.config.data, 'mapper', 'languages', 'fails.json');
+        let langUidMapperPath = path.resolve(this.config.data, 'mapper', 'languages', 'uid-mapper.json');
+        self.langSuccessPath = path.resolve(this.config.data, 'mapper', 'languages', 'success.json');
+        self.languages = fileHelper.readFileSync(path.resolve(langFolderPath, this.langConfig.fileName));
+        self.sourceMasterLanguages = fileHelper.readFileSync(path.resolve(langFolderPath, this.sourceMasterLangConfig.fileName));
+        mkdirp.sync(langMapperPath);
+        if (fs.existsSync(langUidMapperPath)) {
+            self.langUidMapper = fileHelper.readFileSync(langUidMapperPath);
+            self.langUidMapper = self.langUidMapper || {};
+        }
+        return new Promise(async function (resolve, reject) {
+            if (self.languages === undefined || isEmpty(self.languages)) {
+                log(self.config, chalk.white('No Languages Found'), 'success');
+                return resolve({ empty: true });
+            }
+            let sourceMasterLangDetails = self.sourceMasterLanguages && Object.values(self.sourceMasterLanguages);
+            if (sourceMasterLangDetails &&
+                sourceMasterLangDetails[0] &&
+                sourceMasterLangDetails[0]['code'] &&
+                self.masterLanguage['code'] === sourceMasterLangDetails[0]['code']) {
+                await self.checkAndUpdateMasterLocaleName(sourceMasterLangDetails).catch((error) => {
+                    log(self.config, formatError(error), 'warn');
+                });
+            }
+            let langUids = Object.keys(self.languages);
+            return Promise.map(langUids, (langUid) => {
+                let lang = self.languages[langUid];
+                if (!self.langUidMapper.hasOwnProperty(langUid) && lang.code !== self.masterLanguage) {
+                    let requestOption = {
+                        locale: {
+                            code: lang.code,
+                            name: lang.name,
+                        },
+                    };
+                    return self.stackAPIClient
+                        .locale()
+                        .create(requestOption)
+                        .then((locale) => {
+                        self.success.push(locale.items);
+                        self.langUidMapper[langUid] = locale.uid;
+                        fileHelper.writeFileSync(langUidMapperPath, self.langUidMapper);
+                    })
+                        .catch(function (err) {
+                        var _a;
+                        let error = JSON.parse(err.message);
+                        if (error.hasOwnProperty('errorCode') && error.errorCode === 247) {
+                            if ((_a = error === null || error === void 0 ? void 0 : error.errors) === null || _a === void 0 ? void 0 : _a.code) {
+                                log(self.config, error.errors.code[0], 'error');
+                            }
+                            else {
+                                log(self.config, err, 'error');
+                            }
+                            return err;
+                        }
+                        self.fails.push(lang);
+                        log(self.config, `Language '${lang.code}' failed to import\n`, 'error');
+                        log(self.config, formatError(err), 'error');
+                    });
+                }
+                else {
+                    // the language has already been created
+                    log(self.config, `The language '${lang.code}' already exists.`, 'error');
+                }
+                return Promise.resolve();
+                // import 2 languages at a time
+            }, { concurrency: self.reqConcurrency })
+                .then(function () {
+                // languages have imported successfully
+                return self
+                    .updateLocales(langUids)
+                    .then(() => {
+                    fileHelper.writeFileSync(self.langSuccessPath, self.success);
+                    log(self.config, chalk.green('Languages have been imported successfully!'), 'success');
+                    resolve();
+                })
+                    .catch(function (error) {
+                    log(self.config, formatError(error), 'error');
+                    reject(error);
+                });
+            })
+                .catch(function (error) {
+                // error while importing languages
+                fileHelper.writeFileSync(langFailsPath, self.fails);
+                log(self.config, `Language import failed. ${formatError(error)}`, 'error');
+                reject('failed to import Languages');
+            });
+        });
+    }
+    updateLocales(langUids) {
+        let self = this;
+        return new Promise(function (resolve, reject) {
+            Promise.all(langUids.map(async (langUid) => {
+                let lang = {};
+                let requireKeys = self.config.modules.locales.requiredKeys;
+                let _lang = self.languages[langUid];
+                requireKeys.forEach((e) => {
+                    lang[e] = _lang[e];
+                });
+                let langobj = self.stackAPIClient.locale(lang.code);
+                Object.assign(langobj, cloneDeep(lang));
+                langobj.update().then(() => {
+                    // empty function
+                });
+            }))
+                .then(resolve)
+                .catch((error) => {
+                log(self.config, formatError(error), 'error');
+                reject(error);
+            });
+        });
+    }
+    checkAndUpdateMasterLocaleName(sourceMasterLangDetails) {
+        let self = this;
+        return new Promise(async function (resolve, reject) {
+            let masterLangDetails = await self.stackAPIClient
+                .locale(self.masterLanguage['code'])
+                .fetch()
+                .catch((error) => {
+                log(self.config, formatError(error), 'warn');
+            });
+            if (masterLangDetails &&
+                masterLangDetails['name'] &&
+                sourceMasterLangDetails[0]['name'] &&
+                masterLangDetails['name'].toString().toUpperCase() !==
+                    sourceMasterLangDetails[0]['name'].toString().toUpperCase()) {
+                cliux.print('WARNING!!! The master language name for the source and destination is different.', {
+                    color: 'yellow',
+                });
+                cliux.print(`Old Master language name: ${masterLangDetails['name']}`, { color: 'red' });
+                cliux.print(`New Master language name: ${sourceMasterLangDetails[0]['name']}`, { color: 'green' });
+                let confirm = await cliux.inquire({
+                    type: 'confirm',
+                    message: 'Are you sure you want to update name of master language?',
+                    name: 'confirmation',
+                });
+                if (confirm) {
+                    let languid = sourceMasterLangDetails[0] && sourceMasterLangDetails[0]['uid'];
+                    let lang = self.sourceMasterLanguages[languid];
+                    if (!lang)
+                        return reject('Locale not found.!');
+                    const langObj = self.stackAPIClient.locale(lang.code);
+                    Object.assign(langObj, { name: lang.name });
+                    langObj
+                        .update()
+                        .then(() => {
+                        fileHelper.writeFileSync(self.langSuccessPath, self.success);
+                        log(self.config, chalk.green('Master Languages name have been updated successfully!'), 'success');
+                        resolve();
+                    })
+                        .catch(function (error) {
+                        reject(error);
+                    });
+                }
+                else {
+                    resolve();
+                }
+            }
+            else {
+                resolve();
+            }
+        });
+    }
+};

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

@@ -0,0 +1,60 @@
+export = ImportMarketplaceApps;
+declare class ImportMarketplaceApps {
+    constructor(importConfig: any, stackAPIClient: any);
+    client: any;
+    httpClient: any;
+    appOrginalName: any;
+    appUidMapping: {};
+    appNameMapping: {};
+    marketplaceApps: any[];
+    installationUidMapping: {};
+    developerHubBaseUrl: any;
+    marketplaceAppFolderPath: string;
+    marketplaceAppConfig: {
+        dirName: string;
+        fileName: string;
+    };
+    config: any;
+    stackAPIClient: any;
+    start(): Promise<void>;
+    mapperDirPath: string;
+    uidMapperPath: string;
+    getOrgUid(): Promise<void>;
+    getAndValidateEncryptionKey(defaultValue: any, retry?: number): any;
+    nodeCrypto: NodeCrypto;
+    /**
+     * @method startInstallation
+     * @returns {Promise<void>}
+     */
+    startInstallation(): Promise<void>;
+    generateUidMapper(): Promise<{}>;
+    /**
+     * @method handleAllPrivateAppsCreationProcess
+     * @param {Object} options
+     * @returns {Promise<void>}
+     */
+    handleAllPrivateAppsCreationProcess(): Promise<void>;
+    getConfirmationToCreateApps(privateApps: any): Promise<boolean>;
+    createPrivateApps(app: any, uidCleaned?: boolean, appSuffix?: number): any;
+    appCreationCallback(app: any, response: any, appSuffix: any): any;
+    handleNameConflict(app: any, appSuffix: any): any;
+    updateManifestUILocations(locations: any, type?: string, appSuffix?: number): any[];
+    getAppName(name: any, appSuffix?: number): any;
+    /**
+     * @method installApps
+     * @param {Object} options
+     * @returns {Void}
+     */
+    installApps(app: any, installedApps: any): void;
+    makeRedirectUrlCall(response: any, appName: any): Promise<void>;
+    ifAppAlreadyExist(app: any, currentStackApp: any): Promise<any>;
+    confirmToCloseProcess(installation: any): Promise<void>;
+    /**
+     * @method updateAppsConfig
+     * @param {Object<{ data, app }>} param
+     * @returns {Promise<void>}
+     */
+    updateAppsConfig(app: any): Promise<void>;
+    validateAppName(name: any): true | "The app name should be within 3-20 characters long.";
+}
+import { NodeCrypto } from "@contentstack/cli-utilities";

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

@@ -0,0 +1,409 @@
+/*!
+ * Contentstack Export
+ * 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 { cliux, HttpClient, NodeCrypto, managementSDKClient, isAuthenticated, HttpClientDecorator, OauthDecorator, } = require('@contentstack/cli-utilities');
+const { log, fileHelper: { readFileSync, writeFile }, formatError, } = require('../../utils');
+let { default: config } = require('../../config');
+const { getDeveloperHubUrl, getAllStackSpecificApps } = require('../../utils/marketplace-app-helper');
+module.exports = class ImportMarketplaceApps {
+    constructor(importConfig, stackAPIClient) {
+        this.appUidMapping = {};
+        this.appNameMapping = {};
+        this.marketplaceApps = [];
+        this.installationUidMapping = {};
+        this.developerHubBaseUrl = null;
+        this.marketplaceAppFolderPath = '';
+        this.marketplaceAppConfig = config.modules.marketplace_apps;
+        this.config = _.merge(config, importConfig);
+        this.stackAPIClient = stackAPIClient;
+    }
+    async start() {
+        this.mapperDirPath = path.resolve(this.config.data, 'mapper', 'marketplace_apps');
+        this.uidMapperPath = path.join(this.mapperDirPath, 'uid-mapping.json');
+        this.marketplaceAppFolderPath = path.resolve(this.config.data, this.marketplaceAppConfig.dirName);
+        this.marketplaceApps = readFileSync(path.resolve(this.marketplaceAppFolderPath, this.marketplaceAppConfig.fileName));
+        if (_.isEmpty(this.marketplaceApps)) {
+            return Promise.resolve();
+        }
+        else if (!isAuthenticated()) {
+            cliux.print('\nWARNING!!! To import Marketplace apps, you must be logged in. Please check csdx auth:login --help to log in\n', { color: 'yellow' });
+            return Promise.resolve();
+        }
+        this.developerHubBaseUrl = this.config.developerHubBaseUrl || (await getDeveloperHubUrl(this.config));
+        this.client = await managementSDKClient({ endpoint: this.developerHubBaseUrl });
+        await this.getOrgUid();
+        const httpClient = new HttpClient();
+        if (!this.config.auth_token) {
+            this.httpClient = new OauthDecorator(httpClient);
+            const headers = await this.httpClient.preHeadersCheck(this.config);
+            this.httpClient = this.httpClient.headers(headers);
+        }
+        else {
+            this.httpClient = new HttpClientDecorator(httpClient);
+            this.httpClient.headers(this.config);
+        }
+        if (!fs.existsSync(this.mapperDirPath)) {
+            mkdirp.sync(this.mapperDirPath);
+        }
+        return this.startInstallation();
+    }
+    async getOrgUid() {
+        const tempAPIClient = await managementSDKClient({ host: this.config.host });
+        const tempStackData = await tempAPIClient
+            .stack({ api_key: this.config.target_stack })
+            .fetch()
+            .catch((error) => {
+            console.log(error);
+        });
+        if (tempStackData && tempStackData.org_uid) {
+            this.config.org_uid = tempStackData.org_uid;
+        }
+    }
+    async getAndValidateEncryptionKey(defaultValue, retry = 1) {
+        let appConfig = _.find(this.marketplaceApps, ({ configuration, server_configuration }) => !_.isEmpty(configuration) || !_.isEmpty(server_configuration));
+        if (!appConfig) {
+            return defaultValue;
+        }
+        const encryptionKey = await cliux.inquire({
+            type: 'input',
+            name: 'name',
+            default: defaultValue,
+            validate: (key) => {
+                if (!key)
+                    return "Encryption key can't be empty.";
+                return true;
+            },
+            message: 'Enter marketplace app configurations encryption key',
+        });
+        try {
+            appConfig = !_.isEmpty(appConfig.configuration) ? appConfig.configuration : appConfig.server_configuration;
+            this.nodeCrypto = new NodeCrypto({ encryptionKey });
+            this.nodeCrypto.decrypt(appConfig);
+        }
+        catch (error) {
+            if (retry < this.config.getEncryptionKeyMaxRetry && error.code === 'ERR_OSSL_EVP_BAD_DECRYPT') {
+                cliux.print(`Provided encryption key is not valid or your data might be corrupted.! attempt(${retry}/${this.config.getEncryptionKeyMaxRetry})`, { color: 'red' });
+                // NOTE max retry limit is 3
+                return this.getAndValidateEncryptionKey(encryptionKey, retry + 1);
+            }
+            else {
+                cliux.print(`Maximum retry limit exceeded. Closing the process, please try again.! attempt(${retry}/${this.config.getEncryptionKeyMaxRetry})`, { color: 'red' });
+                process.exit(1);
+            }
+        }
+        return encryptionKey;
+    }
+    /**
+     * @method startInstallation
+     * @returns {Promise<void>}
+     */
+    async startInstallation() {
+        const cryptoArgs = {};
+        if (this.config.marketplaceAppEncryptionKey) {
+            cryptoArgs['encryptionKey'] = this.config.marketplaceAppEncryptionKey;
+        }
+        if (this.config.forceStopMarketplaceAppsPrompt) {
+            cryptoArgs['encryptionKey'] = this.config.marketplaceAppEncryptionKey;
+            this.nodeCrypto = new NodeCrypto(cryptoArgs);
+        }
+        else {
+            await this.getAndValidateEncryptionKey(this.config.marketplaceAppEncryptionKey);
+        }
+        // NOTE install all private apps which is not available for stack.
+        await this.handleAllPrivateAppsCreationProcess();
+        const installedApps = await getAllStackSpecificApps(this.developerHubBaseUrl, this.httpClient, this.config);
+        log(this.config, 'Starting marketplace app installation', 'success');
+        for (let app of this.marketplaceApps) {
+            await this.installApps(app, installedApps);
+        }
+        const uidMapper = await this.generateUidMapper();
+        await writeFile(this.uidMapperPath, {
+            app_uid: this.appUidMapping,
+            extension_uid: uidMapper || {},
+            installation_uid: this.installationUidMapping,
+        });
+    }
+    async generateUidMapper() {
+        const listOfNewMeta = [];
+        const listOfOldMeta = [];
+        const extensionUidMapp = {};
+        const allInstalledApps = await getAllStackSpecificApps(this.developerHubBaseUrl, this.httpClient, this.config);
+        for (const app of this.marketplaceApps) {
+            listOfOldMeta.push(..._.map(app.ui_location && app.ui_location.locations, 'meta').flat());
+        }
+        for (const app of allInstalledApps) {
+            listOfNewMeta.push(..._.map(app.ui_location && app.ui_location.locations, 'meta').flat());
+        }
+        for (const { extension_uid, name, path } of _.filter(listOfOldMeta, 'name')) {
+            const meta = _.find(listOfNewMeta, { name, path }) || _.find(listOfNewMeta, { name: this.appNameMapping[name], path });
+            if (meta) {
+                extensionUidMapp[extension_uid] = meta.extension_uid;
+            }
+        }
+        return extensionUidMapp;
+    }
+    /**
+     * @method handleAllPrivateAppsCreationProcess
+     * @param {Object} options
+     * @returns {Promise<void>}
+     */
+    async handleAllPrivateAppsCreationProcess() {
+        const privateApps = _.filter(this.marketplaceApps, { manifest: { visibility: 'private' } });
+        if (_.isEmpty(privateApps)) {
+            return Promise.resolve();
+        }
+        await this.getConfirmationToCreateApps(privateApps);
+        log(this.config, 'Starting developer hub private apps re-creation', 'success');
+        for (let app of privateApps) {
+            // NOTE keys can be passed to install new app in the developer hub
+            app.manifest = _.pick(app.manifest, ['uid', 'name', 'description', 'icon', 'target_type', 'webhook', 'oauth']);
+            this.appOrginalName = app.manifest.name;
+            await this.createPrivateApps(Object.assign({ oauth: app.oauth, webhook: app.webhook, ui_location: app.ui_location }, app.manifest));
+        }
+        this.appOrginalName = undefined;
+    }
+    async getConfirmationToCreateApps(privateApps) {
+        if (!this.config.forceStopMarketplaceAppsPrompt) {
+            if (!(await cliux.confirm(chalk.yellow(`WARNING!!! The listed apps are private apps that are not available in the destination stack: \n\n${_.map(privateApps, ({ manifest: { name } }, index) => `${String(index + 1)}) ${name}`).join('\n')}\n\nWould you like to re-create the private app and then proceed with the installation? (y/n)`)))) {
+                if (await cliux.confirm(chalk.yellow(`\nWARNING!!! Canceling the app re-creation may break the content type and entry import. Would you like to proceed without re-create the private app? (y/n)`))) {
+                    return Promise.resolve(true);
+                }
+                if (!(await cliux.confirm(chalk.yellow('\nWould you like to re-create the private app and then proceed with the installation? (y/n)')))) {
+                    process.exit();
+                }
+            }
+        }
+    }
+    async createPrivateApps(app, uidCleaned = false, appSuffix = 1) {
+        let locations = app.ui_location && app.ui_location.locations;
+        if (!uidCleaned && !_.isEmpty(locations)) {
+            app.ui_location.locations = this.updateManifestUILocations(locations, 'uid');
+        }
+        else if (uidCleaned && !_.isEmpty(locations)) {
+            app.ui_location.locations = this.updateManifestUILocations(locations, 'name', appSuffix);
+        }
+        if (app.name > 20) {
+            app.name = app.name.slice(0, 20);
+        }
+        const response = await this.client
+            .organization(this.config.org_uid)
+            .app()
+            .create(_.omit(app, ['uid']))
+            .catch((error) => error);
+        return this.appCreationCallback(app, response, appSuffix);
+    }
+    async appCreationCallback(app, response, appSuffix) {
+        const { statusText, message } = response || {};
+        if (message) {
+            if (_.toLower(statusText) === 'conflict') {
+                return this.handleNameConflict(app, appSuffix);
+            }
+            else {
+                log(this.config, formatError(message), 'error');
+                if (this.config.forceStopMarketplaceAppsPrompt)
+                    return Promise.resolve();
+                if (await cliux.confirm(chalk.yellow('WARNING!!! The above error may have an impact if the failed app is referenced in entries/content type. Would you like to proceed? (y/n)'))) {
+                    Promise.resolve();
+                }
+                else {
+                    process.exit();
+                }
+            }
+        }
+        else if (response.uid) {
+            // NOTE new app installation
+            log(this.config, `${response.name} app created successfully.!`, 'success');
+            this.appUidMapping[app.uid] = response.uid;
+            this.appNameMapping[this.appOrginalName] = response.name;
+        }
+    }
+    async handleNameConflict(app, appSuffix) {
+        const appName = this.config.forceStopMarketplaceAppsPrompt
+            ? this.getAppName(app.name, appSuffix)
+            : await cliux.inquire({
+                type: 'input',
+                name: 'name',
+                validate: this.validateAppName,
+                default: this.getAppName(app.name, appSuffix),
+                message: `${app.name} app already exist. Enter a new name to create an app.?`,
+            });
+        app.name = appName;
+        return this.createPrivateApps(app, true, appSuffix + 1);
+    }
+    updateManifestUILocations(locations, type = 'uid', appSuffix = 1) {
+        switch (type) {
+            case 'uid':
+                return _.map(locations, (location) => {
+                    if (location.meta) {
+                        location.meta = _.map(location.meta, (meta) => _.omit(meta, ['uid']));
+                    }
+                    return location;
+                });
+            case 'name':
+                return _.map(locations, (location) => {
+                    if (location.meta) {
+                        location.meta = _.map(location.meta, (meta) => {
+                            if (meta.name) {
+                                const name = `${_.first(_.split(meta.name, '◈'))}◈${appSuffix}`;
+                                if (!this.appNameMapping[this.appOrginalName]) {
+                                    this.appNameMapping[this.appOrginalName] = name;
+                                }
+                                meta.name = name;
+                            }
+                            return meta;
+                        });
+                    }
+                    return location;
+                });
+        }
+    }
+    getAppName(name, appSuffix = 1) {
+        if (name.length >= 19)
+            name = name.slice(0, 18);
+        name = `${_.first(_.split(name, '◈'))}◈${appSuffix}`;
+        return name;
+    }
+    /**
+     * @method installApps
+     * @param {Object} options
+     * @returns {Void}
+     */
+    async installApps(app, installedApps) {
+        let updateParam;
+        let installation;
+        const { configuration, server_configuration } = app;
+        const currentStackApp = _.find(installedApps, { manifest: { uid: app.manifest.uid } });
+        if (!currentStackApp) {
+            // NOTE install new app
+            installation = await this.client
+                .organization(this.config.org_uid)
+                .app(this.appUidMapping[app.manifest.uid] || app.manifest.uid)
+                .install({ targetUid: this.config.target_stack, targetType: 'stack' })
+                .catch((error) => error);
+            if (installation.installation_uid) {
+                let appName = this.appNameMapping[app.manifest.name]
+                    ? this.appNameMapping[app.manifest.name]
+                    : app.manifest.name;
+                log(this.config, `${appName} app installed successfully.!`, 'success');
+                await this.makeRedirectUrlCall(installation, app.manifest.name);
+                this.installationUidMapping[app.uid] = installation.installation_uid;
+                updateParam = Object.assign(Object.assign({ manifest: app.manifest }, installation), { configuration, server_configuration });
+            }
+            else if (installation.message) {
+                log(this.config, formatError(installation.message), 'success');
+                await this.confirmToCloseProcess(installation);
+            }
+        }
+        else if (!_.isEmpty(configuration) || !_.isEmpty(server_configuration)) {
+            log(this.config, `${app.manifest.name} is already installed`, 'success');
+            updateParam = await this.ifAppAlreadyExist(app, currentStackApp);
+        }
+        if (!this.appUidMapping[app.manifest.uid]) {
+            this.appUidMapping[app.manifest.uid] = currentStackApp ? currentStackApp.manifest.uid : app.manifest.uid;
+        }
+        // NOTE update configurations
+        if (updateParam && (!_.isEmpty(updateParam.configuration) || !_.isEmpty(updateParam.server_configuration))) {
+            await this.updateAppsConfig(updateParam);
+        }
+    }
+    async makeRedirectUrlCall(response, appName) {
+        if (response.redirect_url) {
+            log(this.config, `${appName} - OAuth api call started.!`, 'info');
+            await new HttpClient({ maxRedirects: 20, maxBodyLength: Infinity })
+                .get(response.redirect_url)
+                .then(async ({ response }) => {
+                if (_.includes([501, 403], response.status)) {
+                    log(this.config, `${appName} - ${response.statusText}, OAuth api call failed.!`, 'error');
+                    log(this.config, formatError(response), 'error');
+                    await this.confirmToCloseProcess({ message: response.data });
+                }
+                else {
+                    log(this.config, `${appName} - OAuth api call completed.!`, 'success');
+                }
+            })
+                .catch((error) => {
+                if (_.includes([501, 403], error.status)) {
+                    log(this.config, formatError(error), 'error');
+                }
+            });
+        }
+    }
+    async ifAppAlreadyExist(app, currentStackApp) {
+        let updateParam;
+        const { manifest: { name }, configuration, server_configuration, } = app;
+        if (!_.isEmpty(configuration) || !_.isEmpty(server_configuration)) {
+            cliux.print(`\nWARNING!!! The ${name} app already exists and it may have its own configuration. But the current app you install has its own configuration which is used internally to manage content.\n`, { color: 'yellow' });
+            const configOption = this.config.forceStopMarketplaceAppsPrompt
+                ? 'Update it with the new configuration.'
+                : await cliux.inquire({
+                    choices: [
+                        'Update it with the new configuration.',
+                        'Do not update the configuration (WARNING!!! If you do not update the configuration, there may be some issues with the content which you import).',
+                        'Exit',
+                    ],
+                    type: 'list',
+                    name: 'value',
+                    message: 'Choose the option to proceed',
+                });
+            if (configOption === 'Exit') {
+                process.exit();
+            }
+            else if (configOption === 'Update it with the new configuration.') {
+                updateParam = Object.assign(Object.assign({ manifest: app.manifest }, currentStackApp), { configuration, server_configuration });
+            }
+        }
+        return updateParam;
+    }
+    async confirmToCloseProcess(installation) {
+        cliux.print(`\nWARNING!!! ${formatError(installation.message)}\n`, { color: 'yellow' });
+        if (!this.config.forceStopMarketplaceAppsPrompt) {
+            if (!(await cliux.confirm(chalk.yellow('WARNING!!! The above error may have an impact if the failed app is referenced in entries/content type. Would you like to proceed? (y/n)')))) {
+                process.exit();
+            }
+        }
+    }
+    /**
+     * @method updateAppsConfig
+     * @param {Object<{ data, app }>} param
+     * @returns {Promise<void>}
+     */
+    updateAppsConfig(app) {
+        const payload = {};
+        const { uid, configuration, server_configuration } = app;
+        if (!_.isEmpty(configuration)) {
+            payload['configuration'] = this.nodeCrypto.decrypt(configuration);
+        }
+        if (!_.isEmpty(server_configuration)) {
+            payload['server_configuration'] = this.nodeCrypto.decrypt(server_configuration);
+        }
+        if (_.isEmpty(app) || _.isEmpty(payload) || !uid) {
+            return Promise.resolve();
+        }
+        let installation = this.client
+            .organization(this.config.org_uid)
+            .app(app.manifest.uid)
+            .installation(uid);
+        installation = Object.assign(installation, payload);
+        return installation
+            .update()
+            .then(async (data) => {
+            if (data) {
+                log(this.config, `${app.manifest.name} app config updated successfully.!`, 'success');
+            }
+        })
+            .catch((error) => log(this.config, formatError(error), 'error'));
+    }
+    validateAppName(name) {
+        if (name.length < 3 || name.length > 20) {
+            return 'The app name should be within 3-20 characters long.';
+        }
+        return true;
+    }
+};

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

@@ -0,0 +1,17 @@
+export = ImportWebhooks;
+declare class ImportWebhooks {
+    constructor(importConfig: any, stackAPIClient: any);
+    config: any;
+    fails: any[];
+    success: any[];
+    webUidMapper: {};
+    webhooksConfig: {
+        dirName: string;
+        fileName: string;
+    };
+    reqConcurrency: number;
+    stackAPIClient: any;
+    start(): Promise<any>;
+    webhooks: any;
+}
+import Promise = require("bluebird");