@contentstack/cli-cm-import 1.6.0 → 1.7.1

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

@@ -0,0 +1,309 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const isEmpty_1 = tslib_1.__importDefault(require("lodash/isEmpty"));
+const find_1 = tslib_1.__importDefault(require("lodash/find"));
+const map_1 = tslib_1.__importDefault(require("lodash/map"));
+const omit_1 = tslib_1.__importDefault(require("lodash/omit"));
+const first_1 = tslib_1.__importDefault(require("lodash/first"));
+const split_1 = tslib_1.__importDefault(require("lodash/split"));
+const toLower_1 = tslib_1.__importDefault(require("lodash/toLower"));
+const filter_1 = tslib_1.__importDefault(require("lodash/filter"));
+const pick_1 = tslib_1.__importDefault(require("lodash/pick"));
+const node_path_1 = require("node:path");
+const cli_utilities_1 = require("@contentstack/cli-utilities");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const config_1 = tslib_1.__importDefault(require("../../config"));
+const utils_1 = require("../../utils");
+const base_class_1 = tslib_1.__importDefault(require("./base-class"));
+const interactive_1 = require("../../utils/interactive");
+class ImportMarketplaceApps extends base_class_1.default {
+    constructor({ importConfig, stackAPIClient }) {
+        super({ importConfig, stackAPIClient });
+        this.marketPlaceAppConfig = config_1.default.modules.marketplace_apps;
+        this.mapperDirPath = (0, node_path_1.join)(this.importConfig.backupDir, 'mapper', 'marketplace_apps');
+        this.marketPlaceFolderPath = (0, node_path_1.join)(this.importConfig.backupDir, this.marketPlaceAppConfig.dirName);
+        this.marketPlaceUidMapperPath = (0, node_path_1.join)(this.mapperDirPath, 'uid-mapping.json');
+        this.httpClient = new cli_utilities_1.HttpClient();
+        this.appNameMapping = {};
+        this.appUidMapping = {};
+        this.appOrginalName = undefined;
+        this.installedApps = [];
+        this.installationUidMapping = {};
+    }
+    /**
+     * @method start
+     * @returns {Promise<void>} Promise<void>
+     */
+    async start() {
+        (0, utils_1.log)(this.importConfig, 'Migrating marketplace apps', 'info');
+        if (utils_1.fileHelper.fileExistsSync(this.marketPlaceFolderPath)) {
+            this.marketplaceApps = utils_1.fsUtil.readFile((0, node_path_1.join)(this.marketPlaceFolderPath, this.marketPlaceAppConfig.fileName), true);
+        }
+        else {
+            (0, utils_1.log)(this.importConfig, `No such file or directory - '${this.marketPlaceFolderPath}'`, 'error');
+            return;
+        }
+        if ((0, isEmpty_1.default)(this.marketplaceApps)) {
+            return Promise.resolve();
+        }
+        else if (!(0, cli_utilities_1.isAuthenticated)()) {
+            cli_utilities_1.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();
+        }
+        await utils_1.fsUtil.makeDirectory(this.mapperDirPath);
+        this.developerHubBaseUrl = this.importConfig.developerHubBaseUrl || (await (0, utils_1.getDeveloperHubUrl)(this.importConfig));
+        this.sdkClient = await (0, cli_utilities_1.managementSDKClient)({ endpoint: this.developerHubBaseUrl });
+        this.importConfig.org_uid = await (0, utils_1.getOrgUid)(this.importConfig);
+        await this.setHttpClient();
+        await this.startInstallation();
+        (0, utils_1.log)(this.importConfig, 'Marketplace apps have been imported successfully!', 'success');
+    }
+    async setHttpClient() {
+        if (!this.importConfig.auth_token) {
+            this.httpClient = new cli_utilities_1.OauthDecorator(this.httpClient);
+            const headers = await this.httpClient.preHeadersCheck(this.importConfig);
+            this.httpClient = this.httpClient.headers(headers);
+        }
+        else {
+            this.httpClient = new cli_utilities_1.HttpClientDecorator(this.httpClient);
+            this.httpClient.headers(this.importConfig);
+        }
+    }
+    /**
+     * @method startInstallation
+     * @returns {Promise<void>}
+     */
+    async startInstallation() {
+        const cryptoArgs = { encryptionKey: '' };
+        if (this.importConfig.marketplaceAppEncryptionKey) {
+            cryptoArgs['encryptionKey'] = this.importConfig.marketplaceAppEncryptionKey;
+        }
+        if (this.importConfig.forceStopMarketplaceAppsPrompt) {
+            cryptoArgs['encryptionKey'] = this.importConfig.marketplaceAppEncryptionKey;
+            this.nodeCrypto = new cli_utilities_1.NodeCrypto(cryptoArgs);
+        }
+        else {
+            await this.getAndValidateEncryptionKey(this.importConfig.marketplaceAppEncryptionKey);
+        }
+        // NOTE install all private apps which is not available for stack.
+        await this.handleAllPrivateAppsCreationProcess();
+        this.installedApps = await (0, utils_1.getAllStackSpecificApps)(this.developerHubBaseUrl, this.httpClient, this.importConfig);
+        (0, utils_1.log)(this.importConfig, 'Starting marketplace app installation', 'success');
+        for (let app of this.marketplaceApps) {
+            await this.installApps(app);
+        }
+        const uidMapper = await this.generateUidMapper();
+        utils_1.fsUtil.writeFile(this.marketPlaceUidMapperPath, {
+            app_uid: this.appUidMapping,
+            extension_uid: uidMapper || {},
+            installation_uid: this.installationUidMapping,
+        });
+    }
+    async generateUidMapper() {
+        var _a, _b;
+        const listOfNewMeta = [];
+        const listOfOldMeta = [];
+        const extensionUidMap = {};
+        this.installedApps = await (0, utils_1.getAllStackSpecificApps)(this.developerHubBaseUrl, this.httpClient, this.importConfig);
+        for (const app of this.marketplaceApps) {
+            listOfOldMeta.push(...(0, map_1.default)((_a = app === null || app === void 0 ? void 0 : app.ui_location) === null || _a === void 0 ? void 0 : _a.locations, 'meta').flat());
+        }
+        for (const app of this.installedApps) {
+            listOfNewMeta.push(...(0, map_1.default)((_b = app === null || app === void 0 ? void 0 : app.ui_location) === null || _b === void 0 ? void 0 : _b.locations, 'meta').flat());
+        }
+        for (const { extension_uid, name, path, uid, data_type } of (0, filter_1.default)(listOfOldMeta, 'name')) {
+            const meta = (0, find_1.default)(listOfNewMeta, { name, path }) ||
+                (0, find_1.default)(listOfNewMeta, { name: this.appNameMapping[name], path }) ||
+                (0, find_1.default)(listOfNewMeta, { name, uid, data_type });
+            if (meta) {
+                extensionUidMap[extension_uid] = meta.extension_uid;
+            }
+        }
+        return extensionUidMap;
+    }
+    async getAndValidateEncryptionKey(defaultValue, retry = 1) {
+        let appConfig = (0, find_1.default)(this.marketplaceApps, ({ configuration, server_configuration }) => !(0, isEmpty_1.default)(configuration) || !(0, isEmpty_1.default)(server_configuration));
+        if (!appConfig) {
+            return defaultValue;
+        }
+        const encryptionKey = await (0, interactive_1.askEncryptionKey)(defaultValue);
+        try {
+            appConfig = !(0, isEmpty_1.default)(appConfig.configuration) ? appConfig.configuration : appConfig.server_configuration;
+            this.nodeCrypto = new cli_utilities_1.NodeCrypto({ encryptionKey });
+            this.nodeCrypto.decrypt(appConfig);
+        }
+        catch (error) {
+            if (retry < this.importConfig.getEncryptionKeyMaxRetry && error.code === 'ERR_OSSL_EVP_BAD_DECRYPT') {
+                cli_utilities_1.cliux.print(`Provided encryption key is not valid or your data might be corrupted.! attempt(${retry}/${this.importConfig.getEncryptionKeyMaxRetry})`, { color: 'red' });
+                // NOTE max retry limit is 3
+                return this.getAndValidateEncryptionKey(encryptionKey, retry + 1);
+            }
+            else {
+                cli_utilities_1.cliux.print(`Maximum retry limit exceeded. Closing the process, please try again.! attempt(${retry}/${this.importConfig.getEncryptionKeyMaxRetry})`, { color: 'red' });
+                process.exit(1);
+            }
+        }
+        return encryptionKey;
+    }
+    /**
+     * @method handleAllPrivateAppsCreationProcess
+     * @returns {Promise<void>}
+     */
+    async handleAllPrivateAppsCreationProcess() {
+        const privateApps = (0, filter_1.default)(this.marketplaceApps, { manifest: { visibility: 'private' } });
+        if ((0, isEmpty_1.default)(privateApps)) {
+            return Promise.resolve();
+        }
+        await (0, utils_1.getConfirmationToCreateApps)(privateApps, this.importConfig);
+        (0, utils_1.log)(this.importConfig, '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 = (0, pick_1.default)(app.manifest, ['uid', 'name', 'description', 'icon', 'target_type', 'webhook', 'oauth']);
+            this.appOrginalName = app.manifest.name;
+            const obj = {
+                oauth: app.oauth,
+                webhook: app.webhook,
+                ui_location: app.ui_location,
+            };
+            await this.createPrivateApps(Object.assign(Object.assign({}, obj), app.manifest));
+        }
+        this.appOrginalName = undefined;
+    }
+    async createPrivateApps(app, uidCleaned = false, appSuffix = 1) {
+        let locations = app.ui_location && app.ui_location.locations;
+        if (!uidCleaned && !(0, isEmpty_1.default)(locations)) {
+            app.ui_location.locations = await this.updateManifestUILocations(locations, 'uid');
+        }
+        else if (uidCleaned && !(0, isEmpty_1.default)(locations)) {
+            app.ui_location.locations = await this.updateManifestUILocations(locations, 'name', appSuffix);
+        }
+        if (app.name > 20) {
+            app.name = app.name.slice(0, 20);
+        }
+        const response = await (0, utils_1.createPrivateApp)(this.sdkClient, this.importConfig, app);
+        return this.appCreationCallback(app, response, appSuffix);
+    }
+    async updateManifestUILocations(locations, type = 'uid', appSuffix = 1) {
+        switch (type) {
+            case 'uid':
+                return (0, map_1.default)(locations, (location) => {
+                    if (location.meta) {
+                        location.meta = (0, map_1.default)(location.meta, (meta) => (0, omit_1.default)(meta, ['uid']));
+                    }
+                    return location;
+                });
+            case 'name':
+                return (0, map_1.default)(locations, (location) => {
+                    if (location.meta) {
+                        location.meta = (0, map_1.default)(location.meta, (meta) => {
+                            if (meta.name) {
+                                const name = `${(0, first_1.default)((0, split_1.default)(meta.name, '◈'))}◈${appSuffix}`;
+                                if (!this.appNameMapping[this.appOrginalName]) {
+                                    this.appNameMapping[this.appOrginalName] = name;
+                                }
+                                meta.name = name;
+                            }
+                            return meta;
+                        });
+                    }
+                    return location;
+                });
+        }
+    }
+    async appCreationCallback(app, response, appSuffix) {
+        const { statusText, message } = response || {};
+        if (message) {
+            if ((0, toLower_1.default)(statusText) === 'conflict') {
+                const updatedApp = await (0, utils_1.handleNameConflict)(app, appSuffix, this.importConfig);
+                return this.createPrivateApps(updatedApp, true, appSuffix + 1);
+            }
+            else {
+                (0, utils_1.log)(this.importConfig, (0, utils_1.formatError)(message), 'error');
+                if (this.importConfig.forceStopMarketplaceAppsPrompt)
+                    return Promise.resolve();
+                if (await cli_utilities_1.cliux.confirm(chalk_1.default.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
+            (0, utils_1.log)(this.importConfig, `${response.name} app created successfully.!`, 'success');
+            this.appUidMapping[app.uid] = response.uid;
+            this.appNameMapping[this.appOrginalName] = response.name;
+        }
+    }
+    /**
+     * @method installApps
+     * @returns {Void}
+     */
+    async installApps(app) {
+        var _a, _b, _c, _d;
+        let updateParam;
+        const { configuration, server_configuration } = app;
+        const currentStackApp = (0, find_1.default)(this.installedApps, { manifest: { uid: (_a = app === null || app === void 0 ? void 0 : app.manifest) === null || _a === void 0 ? void 0 : _a.uid } });
+        if (!currentStackApp) {
+            // NOTE install new app
+            const mappedUid = this.appUidMapping[(_b = app === null || app === void 0 ? void 0 : app.manifest) === null || _b === void 0 ? void 0 : _b.uid];
+            const installation = await (0, utils_1.installApp)(this.sdkClient, this.importConfig, (_c = app === null || app === void 0 ? void 0 : app.manifest) === null || _c === void 0 ? void 0 : _c.uid, mappedUid);
+            if (installation.installation_uid) {
+                const appManifestName = (_d = app === null || app === void 0 ? void 0 : app.manifest) === null || _d === void 0 ? void 0 : _d.name;
+                const appName = this.appNameMapping[appManifestName] ? this.appNameMapping[appManifestName] : appManifestName;
+                (0, utils_1.log)(this.importConfig, `${appName} app installed successfully.!`, 'success');
+                await (0, utils_1.makeRedirectUrlCall)(installation, appManifestName, this.importConfig);
+                this.installationUidMapping[app.uid] = installation.installation_uid;
+                updateParam = Object.assign(Object.assign({ manifest: app.manifest }, installation), { configuration, server_configuration });
+            }
+            else if (installation.message) {
+                (0, utils_1.log)(this.importConfig, (0, utils_1.formatError)(installation.message), 'success');
+                await (0, utils_1.confirmToCloseProcess)(installation, this.importConfig);
+            }
+        }
+        else if (!(0, isEmpty_1.default)(configuration) || !(0, isEmpty_1.default)(server_configuration)) {
+            (0, utils_1.log)(this.importConfig, `${app.manifest.name} is already installed`, 'success');
+            updateParam = await (0, utils_1.ifAppAlreadyExist)(app, currentStackApp, this.importConfig);
+        }
+        if (!this.appUidMapping[app.manifest.uid]) {
+            this.appUidMapping[app.manifest.uid] = currentStackApp ? currentStackApp.manifest.uid : app.manifest.uid;
+        }
+        // NOTE update configurations
+        if (updateParam && (!(0, isEmpty_1.default)(updateParam.configuration) || !(0, isEmpty_1.default)(updateParam.server_configuration))) {
+            await this.updateAppsConfig(updateParam);
+        }
+    }
+    /**
+     * @method updateAppsConfig
+     * @returns {Promise<void>}
+     */
+    async updateAppsConfig(app) {
+        const payload = { configuration: {}, server_configuration: {} };
+        const { uid, configuration, server_configuration } = app;
+        if (!(0, isEmpty_1.default)(configuration)) {
+            payload['configuration'] = this.nodeCrypto.decrypt(configuration);
+        }
+        if (!(0, isEmpty_1.default)(server_configuration)) {
+            payload['server_configuration'] = this.nodeCrypto.decrypt(server_configuration);
+        }
+        if ((0, isEmpty_1.default)(app) || (0, isEmpty_1.default)(payload) || !uid) {
+            return Promise.resolve();
+        }
+        // TODO migrate this HTTP API call into SDK
+        // NOTE Use updateAppConfig(this.sdkClient, this.importConfig, app, payload) utility when migrating to SDK call;
+        return this.httpClient
+            .put(`${this.developerHubBaseUrl}/installations/${uid}`, payload)
+            .then(({ data }) => {
+            if (data.message) {
+                (0, utils_1.log)(this.importConfig, (0, utils_1.formatError)(data.message), 'success');
+            }
+            else {
+                (0, utils_1.log)(this.importConfig, `${app.manifest.name} app config updated successfully.!`, 'success');
+            }
+        })
+            .catch((error) => (0, utils_1.log)(this.importConfig, (0, utils_1.formatError)(error), 'error'));
+    }
+}
+exports.default = ImportMarketplaceApps;

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

@@ -0,0 +1,27 @@
+import BaseClass, { ApiOptions } from './base-class';
+import { ModuleClassParams } from '../../types';
+export default class ImportWebhooks extends BaseClass {
+    private mapperDirPath;
+    private webhooksFolderPath;
+    private webhookUidMapperPath;
+    private createdWebhooksPath;
+    private failedWebhooksPath;
+    private webhooksConfig;
+    private webhooks;
+    private webhookUidMapper;
+    private createdWebhooks;
+    private failedWebhooks;
+    constructor({ importConfig, stackAPIClient }: ModuleClassParams);
+    /**
+     * @method start
+     * @returns {Promise<void>} Promise<void>
+     */
+    start(): Promise<void>;
+    importWebhooks(): Promise<string>;
+    /**
+     * @method serializeWebhooks
+     * @param {ApiOptions} apiOptions ApiOptions
+     * @returns {ApiOptions} ApiOptions
+     */
+    serializeWebhooks(apiOptions: ApiOptions): ApiOptions;
+}

package/lib/import/modules/webhooks.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const isEmpty_1 = tslib_1.__importDefault(require("lodash/isEmpty"));
+const values_1 = tslib_1.__importDefault(require("lodash/values"));
+const node_path_1 = require("node:path");
+const config_1 = tslib_1.__importDefault(require("../../config"));
+const utils_1 = require("../../utils");
+const base_class_1 = tslib_1.__importDefault(require("./base-class"));
+class ImportWebhooks extends base_class_1.default {
+    constructor({ importConfig, stackAPIClient }) {
+        super({ importConfig, stackAPIClient });
+        this.webhooksConfig = config_1.default.modules.webhooks;
+        this.mapperDirPath = (0, node_path_1.join)(this.importConfig.backupDir, 'mapper', 'webhooks');
+        this.webhooksFolderPath = (0, node_path_1.join)(this.importConfig.backupDir, this.webhooksConfig.dirName);
+        this.webhookUidMapperPath = (0, node_path_1.join)(this.mapperDirPath, 'uid-mapping.json');
+        this.createdWebhooksPath = (0, node_path_1.join)(this.mapperDirPath, 'success.json');
+        this.failedWebhooksPath = (0, node_path_1.join)(this.mapperDirPath, 'fails.json');
+        this.webhooks = {};
+        this.failedWebhooks = [];
+        this.createdWebhooks = [];
+        this.webhookUidMapper = {};
+    }
+    /**
+     * @method start
+     * @returns {Promise<void>} Promise<void>
+     */
+    async start() {
+        var _a, _b;
+        (0, utils_1.log)(this.importConfig, 'Migrating webhooks', 'info');
+        //Step1 check folder exists or not
+        if (utils_1.fileHelper.fileExistsSync(this.webhooksFolderPath)) {
+            this.webhooks = utils_1.fsUtil.readFile((0, node_path_1.join)(this.webhooksFolderPath, 'webhooks.json'), true);
+        }
+        else {
+            (0, utils_1.log)(this.importConfig, `No such file or directory - '${this.webhooksFolderPath}'`, 'error');
+            return;
+        }
+        //create webhooks in mapper directory
+        await utils_1.fsUtil.makeDirectory(this.mapperDirPath);
+        this.webhookUidMapper = utils_1.fileHelper.fileExistsSync(this.webhookUidMapperPath)
+            ? utils_1.fsUtil.readFile((0, node_path_1.join)(this.webhookUidMapperPath), true)
+            : {};
+        await this.importWebhooks();
+        if ((_a = this.createdWebhooks) === null || _a === void 0 ? void 0 : _a.length) {
+            utils_1.fsUtil.writeFile(this.createdWebhooksPath, this.createdWebhooks);
+        }
+        if ((_b = this.failedWebhooks) === null || _b === void 0 ? void 0 : _b.length) {
+            utils_1.fsUtil.writeFile(this.failedWebhooksPath, this.failedWebhooks);
+        }
+        (0, utils_1.log)(this.importConfig, 'Webhooks have been imported successfully!', 'success');
+    }
+    async importWebhooks() {
+        if (this.webhooks === undefined || (0, isEmpty_1.default)(this.webhooks)) {
+            (0, utils_1.log)(this.importConfig, 'No Webhook Found', 'info');
+            return (0, node_path_1.resolve)();
+        }
+        const apiContent = (0, values_1.default)(this.webhooks);
+        const onSuccess = ({ response, apiData: { uid, name } = { uid: null, name: '' } }) => {
+            this.createdWebhooks.push(response);
+            this.webhookUidMapper[uid] = response.uid;
+            (0, utils_1.log)(this.importConfig, `Webhook '${name}' imported successfully`, 'success');
+            utils_1.fsUtil.writeFile(this.webhookUidMapperPath, this.webhookUidMapper);
+        };
+        const onReject = ({ error, apiData }) => {
+            var _a;
+            const err = (error === null || error === void 0 ? void 0 : error.message) ? JSON.parse(error.message) : error;
+            const { name } = apiData;
+            if ((_a = err === null || err === void 0 ? void 0 : err.errors) === null || _a === void 0 ? void 0 : _a.name) {
+                (0, utils_1.log)(this.importConfig, `Webhook '${name}' already exists`, 'info');
+            }
+            else {
+                this.failedWebhooks.push(apiData);
+                (0, utils_1.log)(this.importConfig, `Webhook '${name}' failed to be import. ${(0, utils_1.formatError)(error)}`, 'error');
+            }
+        };
+        await this.makeConcurrentCall({
+            apiContent,
+            processName: 'create webhooks',
+            apiParams: {
+                serializeData: this.serializeWebhooks.bind(this),
+                reject: onReject.bind(this),
+                resolve: onSuccess.bind(this),
+                entity: 'create-webhooks',
+                includeParamOnCompletion: true,
+            },
+            concurrencyLimit: config_1.default.fetchConcurrency || 1,
+        }, undefined, false);
+    }
+    /**
+     * @method serializeWebhooks
+     * @param {ApiOptions} apiOptions ApiOptions
+     * @returns {ApiOptions} ApiOptions
+     */
+    serializeWebhooks(apiOptions) {
+        const { apiData: webhook } = apiOptions;
+        if (this.webhookUidMapper.hasOwnProperty(webhook.uid)) {
+            (0, utils_1.log)(this.importConfig, `Webhook '${webhook.name}' already exists. Skipping it to avoid duplicates!`, 'info');
+            apiOptions.entity = undefined;
+        }
+        else {
+            if (this.importConfig.importWebhookStatus === 'disable' || this.importConfig.importWebhookStatus !== 'current') {
+                webhook.disabled = true;
+            }
+            apiOptions.apiData = webhook;
+        }
+        return apiOptions;
+    }
+}
+exports.default = ImportWebhooks;

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

@@ -39,9 +39,11 @@ module.exports = class ImportCustomRoles {
             }
             self.customRolesUids = Object.keys(self.customRoles);
             self.localesUidMap = await getLocalesUidMap(self.stackAPIClient, self.config, self.customRolesLocales);
+            self.environmentsUidMap = {};
             if (fs.existsSync(environmentsUidMapperFolderPath)) {
                 self.environmentsUidMap = fileHelper.readFileSync(path.resolve(environmentsUidMapperFolderPath, 'uid-mapping.json'));
             }
+            self.entriesUidMap = {};
             if (fs.existsSync(entriesUidMapperFolderPath)) {
                 self.entriesUidMap = fileHelper.readFileSync(path.resolve(entriesUidMapperFolderPath, 'uid-mapping.json'));
             }

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

@@ -619,7 +619,7 @@ module.exports = class ImportEntries {
                     // empty function
                 })
                     .catch((_error) => {
-                    addlogs(this.config, formatError(error), 'error');
+                    addlogs(this.config, formatError(_error), 'error');
                     reject(`Failed suppress content type ${schema.uid} reference fields`);
                 });
                 // update 5 content types at a time
@@ -786,10 +786,15 @@ module.exports = class ImportEntries {
         return new Promise((resolve, reject) => {
             if (schema.field_rules) {
                 let fieldRuleLength = schema.field_rules.length;
+                const fieldDatatypeMap = {};
+                for (let i = 0; i < schema.schema.length; i++) {
+                    const field = schema.schema[i].uid;
+                    fieldDatatypeMap[field] = schema.schema[i].data_type;
+                }
                 for (let k = 0; k < fieldRuleLength; k++) {
                     let fieldRuleConditionLength = schema.field_rules[k].conditions.length;
                     for (let i = 0; i < fieldRuleConditionLength; i++) {
-                        if (schema.field_rules[k].conditions[i].operand_field === 'reference') {
+                        if (fieldDatatypeMap[schema.field_rules[k].conditions[i].operand_field] === 'reference') {
                             let fieldRulesValue = schema.field_rules[k].conditions[i].value;
                             let fieldRulesArray = fieldRulesValue.split('.');
                             let updatedValue = [];
@@ -824,6 +829,7 @@ module.exports = class ImportEntries {
             })
                 .catch((error) => {
                 log(this.config, `failed to update the field rules ${formatError(error)}`);
+                return reject(error);
             });
         });
     }

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

@@ -7,6 +7,7 @@ declare class ImportExtensions {
     extensionsConfig: {
         dirName: string;
         fileName: string;
+        validKeys: string[];
     };
     reqConcurrency: number;
     config: any;

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

@@ -141,8 +141,10 @@ module.exports = class ImportMarketplaceApps {
         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 });
+        for (const { extension_uid, name, path, uid, data_type } of _.filter(listOfOldMeta, 'name')) {
+            const meta = _.find(listOfNewMeta, { name, path }) ||
+                _.find(listOfNewMeta, { name: this.appNameMapping[name], path }) ||
+                _.find(listOfNewMeta, { name, uid, data_type });
             if (meta) {
                 extensionUidMapp[extension_uid] = meta.extension_uid;
             }
@@ -386,15 +388,13 @@ module.exports = class ImportMarketplaceApps {
         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) {
+        return this.httpClient
+            .put(`${this.developerHubBaseUrl}/installations/${uid}`, payload)
+            .then(({ data }) => {
+            if (data.message) {
+                log(this.config, formatError(data.message), 'success');
+            }
+            else {
                 log(this.config, `${app.manifest.name} app config updated successfully.!`, 'success');
             }
         })

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

@@ -28,6 +28,7 @@ export default interface DefaultConfig {
         extensions: {
             dirName: string;
             fileName: string;
+            validKeys: string[];
         };
         webhooks: {
             dirName: string;
@@ -73,6 +74,12 @@ export default interface DefaultConfig {
             validKeys: string[];
             limit: number;
         };
+        'content-types': {
+            dirName: string;
+            fileName: string;
+            validKeys: string[];
+            limit: number;
+        };
         entries: {
             dirName: string;
             fileName: string;
@@ -86,6 +93,12 @@ export default interface DefaultConfig {
             validKeys: string[];
             limit: number;
         };
+        'global-fields': {
+            dirName: string;
+            fileName: string;
+            validKeys: string[];
+            limit: number;
+        };
         stack: {
             dirName: string;
             fileName: string;

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

@@ -40,6 +40,7 @@ export default interface ImportConfig extends DefaultConfig, ExternalConfig {
     backupConcurrency?: number;
     authtoken?: string;
     destinationStackName?: string;
+    org_uid?: string;
 }
 type branch = {
     uid: string;

package/lib/types/index.d.ts

@@ -26,5 +26,38 @@ export type ModuleClassParams = {
     importConfig: ImportConfig;
     moduleName: Modules;
 };
+export interface Extensions {
+    dirName: string;
+    fileName: string;
+    dependencies?: Modules[];
+}
+export interface MarketplaceAppsConfig {
+    dirName: string;
+    fileName: string;
+    dependencies?: Modules[];
+}
+export interface EnvironmentConfig {
+    dirName: string;
+    fileName: string;
+    dependencies?: Modules[];
+}
+export interface LabelConfig {
+    dirName: string;
+    fileName: string;
+}
+export interface WebhookConfig {
+    dirName: string;
+    fileName: string;
+}
+export interface WorkflowConfig {
+    dirName: string;
+    fileName: string;
+    invalidKeys: string[];
+}
+export interface CustomRoleConfig {
+    dirName: string;
+    fileName: string;
+    customRolesLocalesFileName: string;
+}
 export { default as DefaultConfig } from './default-config';
 export { default as ImportConfig } from './import-config';

package/lib/types/index.js

@@ -1,2 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+;
+;

package/lib/utils/content-type-helper.d.ts

@@ -46,4 +46,6 @@ export declare const schemaTemplate: {
  * MIT Licensed
  */
 export declare const suppressSchemaReference: (schema: any, flag: any) => void;
-export declare const removeReferenceFields: (schema: any, flag: any, stackAPIClient: any) => Promise<void>;
+export declare const removeReferenceFields: (schema: any, flag: {
+    supressed: boolean;
+}, stackAPIClient: any) => Promise<boolean | void>;

package/lib/utils/content-type-helper.js

@@ -79,7 +79,7 @@ const suppressSchemaReference = function (schema, flag) {
     }
 };
 exports.suppressSchemaReference = suppressSchemaReference;
-const removeReferenceFields = async function (schema, flag, stackAPIClient) {
+const removeReferenceFields = async function (schema, flag = { supressed: false }, stackAPIClient) {
     for (let i = 0; i < schema.length; i++) {
         if (schema[i].data_type === 'group') {
             await (0, exports.removeReferenceFields)(schema[i].schema, flag, stackAPIClient);
@@ -128,6 +128,7 @@ const removeReferenceFields = async function (schema, flag, stackAPIClient) {
                     });
                 }
             }
+            return true;
         }
         else if (
         // handling entry references in json rte
@@ -137,6 +138,7 @@ const removeReferenceFields = async function (schema, flag, stackAPIClient) {
             schema[i].reference_to.length > 1) {
             flag.supressed = true;
             schema[i].reference_to = ['sys_assets'];
+            return true;
         }
     }
 };