@contentstack/cli-cm-export 1.5.9 → 1.7.0

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

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const keys_1 = tslib_1.__importDefault(require("lodash/keys"));
+const find_1 = tslib_1.__importDefault(require("lodash/find"));
+const forEach_1 = tslib_1.__importDefault(require("lodash/forEach"));
+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 base_class_1 = tslib_1.__importDefault(require("./base-class"));
+const utils_1 = require("../../utils");
+class ExportCustomRoles extends base_class_1.default {
+    constructor({ exportConfig, stackAPIClient }) {
+        super({ exportConfig, stackAPIClient });
+        this.customRoles = {};
+        this.customRolesConfig = config_1.default.modules.customRoles;
+        this.existingRoles = { Admin: 1, Developer: 1, 'Content Manager': 1 };
+        this.localesMap = {};
+        this.sourceLocalesMap = {};
+    }
+    async start() {
+        (0, utils_1.log)(this.exportConfig, 'Starting custom roles export', 'info');
+        this.rolesFolderPath = (0, node_path_1.resolve)(this.exportConfig.data, this.exportConfig.branchName || '', this.customRolesConfig.dirName);
+        await utils_1.fsUtil.makeDirectory(this.rolesFolderPath);
+        this.customRolesLocalesFilepath = (0, node_path_1.resolve)(this.rolesFolderPath, this.customRolesConfig.customRolesLocalesFileName);
+        await this.getCustomRoles();
+        await this.getLocales();
+        await this.getCustomRolesLocales();
+    }
+    async getCustomRoles() {
+        const roles = await this.stack
+            .role()
+            .fetchAll({ include_rules: true, include_permissions: true })
+            .then((data) => data)
+            .catch((err) => (0, utils_1.log)(this.exportConfig, `Failed to fetch roles. ${(0, utils_1.formatError)(err)}`, 'error'));
+        const customRoles = roles.items.filter((role) => !this.existingRoles[role.name]);
+        if (!customRoles.length) {
+            (0, utils_1.log)(this.exportConfig, 'No custom roles were found in the Stack', 'info');
+            return;
+        }
+        customRoles.forEach((role) => {
+            (0, utils_1.log)(this.exportConfig, `'${role === null || role === void 0 ? void 0 : role.name}' role was exported successfully`, 'info');
+            this.customRoles[role.uid] = role;
+        });
+        utils_1.fsUtil.writeFile((0, node_path_1.resolve)(this.rolesFolderPath, this.customRolesConfig.fileName), this.customRoles);
+    }
+    async getLocales() {
+        const locales = await this.stack
+            .locale()
+            .query({})
+            .find()
+            .then((data) => data)
+            .catch((err) => (0, utils_1.log)(this.exportConfig, `Failed to fetch locales. ${(0, utils_1.formatError)(err)}`, 'error'));
+        for (const locale of locales.items) {
+            this.sourceLocalesMap[locale.uid] = locale;
+        }
+    }
+    async getCustomRolesLocales() {
+        var _a, _b;
+        for (const role of (0, values_1.default)(this.customRoles)) {
+            const customRole = role;
+            const rulesLocales = (0, find_1.default)(customRole.rules, (rule) => rule.module === 'locale');
+            if ((_a = rulesLocales === null || rulesLocales === void 0 ? void 0 : rulesLocales.locales) === null || _a === void 0 ? void 0 : _a.length) {
+                (0, forEach_1.default)(rulesLocales.locales, (locale) => {
+                    this.localesMap[locale] = 1;
+                });
+            }
+        }
+        if ((_b = (0, keys_1.default)(this.localesMap)) === null || _b === void 0 ? void 0 : _b.length) {
+            for (const locale in this.localesMap) {
+                if (this.sourceLocalesMap[locale] !== undefined) {
+                    const sourceLocale = this.sourceLocalesMap[locale];
+                    sourceLocale === null || sourceLocale === void 0 ? true : delete sourceLocale.stackHeaders;
+                }
+                this.localesMap[locale] = this.sourceLocalesMap[locale];
+            }
+            utils_1.fsUtil.writeFile(this.customRolesLocalesFilepath, this.localesMap);
+        }
+    }
+}
+exports.default = ExportCustomRoles;

package/lib/export/modules/environments.d.ts

@@ -0,0 +1,12 @@
+import BaseClass from './base-class';
+import { ModuleClassParams } from '../../types';
+export default class ExportEnvironments extends BaseClass {
+    private environments;
+    private environmentConfig;
+    environmentsFolderPath: string;
+    private qs;
+    constructor({ exportConfig, stackAPIClient }: ModuleClassParams);
+    start(): Promise<void>;
+    getEnvironments(skip?: number): Promise<void>;
+    sanitizeAttribs(environments: Record<string, string>[]): void;
+}

package/lib/export/modules/environments.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const node_path_1 = require("node:path");
+const omit_1 = tslib_1.__importDefault(require("lodash/omit"));
+const isEmpty_1 = tslib_1.__importDefault(require("lodash/isEmpty"));
+const config_1 = tslib_1.__importDefault(require("../../config"));
+const base_class_1 = tslib_1.__importDefault(require("./base-class"));
+const utils_1 = require("../../utils");
+class ExportEnvironments extends base_class_1.default {
+    constructor({ exportConfig, stackAPIClient }) {
+        super({ exportConfig, stackAPIClient });
+        this.environments = {};
+        this.environmentConfig = config_1.default.modules.environments;
+        this.qs = { include_count: true };
+    }
+    async start() {
+        (0, utils_1.log)(this.exportConfig, 'Starting environment export', 'info');
+        this.environmentsFolderPath = (0, node_path_1.resolve)(this.exportConfig.data, this.exportConfig.branchName || '', this.environmentConfig.dirName);
+        await utils_1.fsUtil.makeDirectory(this.environmentsFolderPath);
+        await this.getEnvironments();
+        if (this.environments === undefined || (0, isEmpty_1.default)(this.environments)) {
+            (0, utils_1.log)(this.exportConfig, 'No environments found', 'info');
+        }
+        else {
+            utils_1.fsUtil.writeFile((0, node_path_1.resolve)(this.environmentsFolderPath, this.environmentConfig.fileName), this.environments);
+            (0, utils_1.log)(this.exportConfig, 'All the environments have been exported successfully!', 'success');
+        }
+    }
+    async getEnvironments(skip = 0) {
+        if (skip) {
+            this.qs.skip = skip;
+        }
+        await this.stack
+            .environment()
+            .query(this.qs)
+            .find()
+            .then(async (data) => {
+            const { items, count } = data;
+            if (items === null || items === void 0 ? void 0 : items.length) {
+                this.sanitizeAttribs(items);
+                skip += this.environmentConfig.limit || 100;
+                if (skip >= count) {
+                    return;
+                }
+                return await this.getEnvironments(skip);
+            }
+        })
+            .catch((error) => {
+            (0, utils_1.log)(this.exportConfig, `Failed to export environments. ${(0, utils_1.formatError)(error)}`, 'error');
+            (0, utils_1.log)(this.exportConfig, error, 'error');
+        });
+    }
+    sanitizeAttribs(environments) {
+        var _a;
+        for (let index = 0; index < (environments === null || environments === void 0 ? void 0 : environments.length); index++) {
+            const extUid = environments[index].uid;
+            const envName = (_a = environments[index]) === null || _a === void 0 ? void 0 : _a.name;
+            this.environments[extUid] = (0, omit_1.default)(environments[index], ['ACL']);
+            (0, utils_1.log)(this.exportConfig, `'${envName}' environment was exported successfully`, 'success');
+        }
+    }
+}
+exports.default = ExportEnvironments;

package/lib/export/modules/extensions.d.ts

@@ -0,0 +1,12 @@
+import BaseClass from './base-class';
+import { ExtensionsConfig, ModuleClassParams } from '../../types';
+export default class ExportExtensions extends BaseClass {
+    private extensionsFolderPath;
+    private extensions;
+    extensionConfig: ExtensionsConfig;
+    private qs;
+    constructor({ exportConfig, stackAPIClient }: ModuleClassParams);
+    start(): Promise<void>;
+    getExtensions(skip?: number): Promise<void>;
+    sanitizeAttribs(extensions: Record<string, string>[]): void;
+}

package/lib/export/modules/extensions.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const omit_1 = tslib_1.__importDefault(require("lodash/omit"));
+const isEmpty_1 = tslib_1.__importDefault(require("lodash/isEmpty"));
+const node_path_1 = require("node:path");
+const config_1 = tslib_1.__importDefault(require("../../config"));
+const base_class_1 = tslib_1.__importDefault(require("./base-class"));
+const utils_1 = require("../../utils");
+class ExportExtensions extends base_class_1.default {
+    constructor({ exportConfig, stackAPIClient }) {
+        super({ exportConfig, stackAPIClient });
+        this.extensions = {};
+        this.extensionConfig = config_1.default.modules.extensions;
+        this.qs = { include_count: true };
+    }
+    async start() {
+        (0, utils_1.log)(this.exportConfig, 'Starting extension export', 'info');
+        this.extensionsFolderPath = (0, node_path_1.resolve)(this.exportConfig.data, this.exportConfig.branchName || '', this.extensionConfig.dirName);
+        await utils_1.fsUtil.makeDirectory(this.extensionsFolderPath);
+        await this.getExtensions();
+        if (this.extensions === undefined || (0, isEmpty_1.default)(this.extensions)) {
+            (0, utils_1.log)(this.exportConfig, 'No extensions found', 'info');
+        }
+        else {
+            utils_1.fsUtil.writeFile((0, node_path_1.resolve)(this.extensionsFolderPath, this.extensionConfig.fileName), this.extensions);
+            (0, utils_1.log)(this.exportConfig, 'All the extensions have been exported successfully!', 'success');
+        }
+    }
+    async getExtensions(skip = 0) {
+        if (skip) {
+            this.qs.skip = skip;
+        }
+        await this.stack
+            .extension()
+            .query(this.qs)
+            .find()
+            .then(async (data) => {
+            const { items, count } = data;
+            if (items === null || items === void 0 ? void 0 : items.length) {
+                this.sanitizeAttribs(items);
+                skip += this.extensionConfig.limit || 100;
+                if (skip >= count) {
+                    return;
+                }
+                return await this.getExtensions(skip);
+            }
+        })
+            .catch((error) => {
+            (0, utils_1.log)(this.exportConfig, `Failed to export extensions. ${(0, utils_1.formatError)(error)}`, 'error');
+            (0, utils_1.log)(this.exportConfig, error, 'error');
+        });
+    }
+    sanitizeAttribs(extensions) {
+        var _a;
+        for (let index = 0; index < (extensions === null || extensions === void 0 ? void 0 : extensions.length); index++) {
+            const extUid = extensions[index].uid;
+            const extTitle = (_a = extensions[index]) === null || _a === void 0 ? void 0 : _a.title;
+            this.extensions[extUid] = (0, omit_1.default)(extensions[index], ['SYS_ACL']);
+            (0, utils_1.log)(this.exportConfig, `'${extTitle}' extension was exported successfully`, 'success');
+        }
+    }
+}
+exports.default = ExportExtensions;

package/lib/export/modules/global-fields.d.ts

@@ -0,0 +1,14 @@
+import { ExportConfig, ModuleClassParams } from '../../types';
+import BaseClass from './base-class';
+export default class GlobalFieldsExport extends BaseClass {
+    private stackAPIClient;
+    exportConfig: ExportConfig;
+    private qs;
+    private globalFieldsConfig;
+    private globalFieldsDirPath;
+    private globalFields;
+    constructor({ exportConfig, stackAPIClient }: ModuleClassParams);
+    start(): Promise<void>;
+    getGlobalFields(skip?: number): Promise<any>;
+    sanitizeAttribs(globalFields: Record<string, string>[]): void;
+}

package/lib/export/modules/global-fields.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const path = tslib_1.__importStar(require("path"));
+const utils_1 = require("../../utils");
+const base_class_1 = tslib_1.__importDefault(require("./base-class"));
+class GlobalFieldsExport extends base_class_1.default {
+    constructor({ exportConfig, stackAPIClient }) {
+        super({ exportConfig, stackAPIClient });
+        this.stackAPIClient = stackAPIClient;
+        this.globalFieldsConfig = exportConfig.modules['global-fields'];
+        this.qs = {
+            skip: 0,
+            asc: 'updated_at',
+            include_count: true,
+            limit: this.globalFieldsConfig.limit,
+        };
+        this.globalFieldsDirPath = path.resolve(exportConfig.data, exportConfig.branchName || '', this.globalFieldsConfig.dirName);
+        this.globalFields = [];
+    }
+    async start() {
+        try {
+            (0, utils_1.log)(this.exportConfig, 'Starting global fields export', 'success');
+            await utils_1.fsUtil.makeDirectory(this.globalFieldsDirPath);
+            await this.getGlobalFields();
+            utils_1.fsUtil.writeFile(path.join(this.globalFieldsDirPath, this.globalFieldsConfig.fileName), this.globalFields);
+            (0, utils_1.log)(this.exportConfig, 'Completed global fields export', 'success');
+        }
+        catch (error) {
+            (0, utils_1.log)(this.exportConfig, `Failed to export global fields. ${(0, utils_1.formatError)(error)}`, 'error');
+            throw new Error('Failed to export global fields');
+        }
+    }
+    async getGlobalFields(skip = 0) {
+        if (skip) {
+            this.qs.skip = skip;
+        }
+        let globalFieldsFetchResponse = await this.stackAPIClient.globalField().query(this.qs).find();
+        if (Array.isArray(globalFieldsFetchResponse.items) && globalFieldsFetchResponse.items.length > 0) {
+            this.sanitizeAttribs(globalFieldsFetchResponse.items);
+            skip += this.globalFieldsConfig.limit || 100;
+            if (skip >= globalFieldsFetchResponse.count) {
+                return;
+            }
+            return await this.getGlobalFields(skip);
+        }
+    }
+    sanitizeAttribs(globalFields) {
+        globalFields.forEach((globalField) => {
+            for (let key in globalField) {
+                if (this.globalFieldsConfig.validKeys.indexOf(key) === -1) {
+                    delete globalField[key];
+                }
+            }
+            this.globalFields.push(globalField);
+        });
+    }
+}
+exports.default = GlobalFieldsExport;

package/lib/export/modules/index.d.ts

@@ -0,0 +1,3 @@
+import { ModuleClassParams } from '../../types';
+export default function startModuleExport(modulePayload: ModuleClassParams): Promise<any>;
+export { default as ExportAssets } from './assets';

package/lib/export/modules/index.js

@@ -0,0 +1,38 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExportAssets = void 0;
+async function startModuleExport(modulePayload) {
+    const { default: ModuleRunner } = await (_a = `./${modulePayload.moduleName}`, Promise.resolve().then(() => __importStar(require(_a))));
+    const moduleRunner = new ModuleRunner(modulePayload);
+    return moduleRunner.start();
+}
+exports.default = startModuleExport;
+var assets_1 = require("./assets");
+Object.defineProperty(exports, "ExportAssets", { enumerable: true, get: function () { return __importDefault(assets_1).default; } });

package/lib/export/modules/labels.d.ts

@@ -0,0 +1,12 @@
+import BaseClass from './base-class';
+import { ModuleClassParams } from '../../types';
+export default class ExportLabels extends BaseClass {
+    private labels;
+    private labelConfig;
+    labelsFolderPath: string;
+    private qs;
+    constructor({ exportConfig, stackAPIClient }: ModuleClassParams);
+    start(): Promise<void>;
+    getLabels(skip?: number): Promise<void>;
+    sanitizeAttribs(labels: Record<string, string>[]): void;
+}

package/lib/export/modules/labels.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const omit_1 = tslib_1.__importDefault(require("lodash/omit"));
+const isEmpty_1 = tslib_1.__importDefault(require("lodash/isEmpty"));
+const node_path_1 = require("node:path");
+const config_1 = tslib_1.__importDefault(require("../../config"));
+const base_class_1 = tslib_1.__importDefault(require("./base-class"));
+const utils_1 = require("../../utils");
+class ExportLabels extends base_class_1.default {
+    constructor({ exportConfig, stackAPIClient }) {
+        super({ exportConfig, stackAPIClient });
+        this.labels = {};
+        this.labelConfig = config_1.default.modules.labels;
+        this.qs = { include_count: true };
+    }
+    async start() {
+        (0, utils_1.log)(this.exportConfig, 'Starting labels export', 'info');
+        this.labelsFolderPath = (0, node_path_1.resolve)(this.exportConfig.data, this.exportConfig.branchName || '', this.labelConfig.dirName);
+        await utils_1.fsUtil.makeDirectory(this.labelsFolderPath);
+        await this.getLabels();
+        if (this.labels === undefined || (0, isEmpty_1.default)(this.labels)) {
+            (0, utils_1.log)(this.exportConfig, 'No labels found', 'info');
+        }
+        else {
+            utils_1.fsUtil.writeFile((0, node_path_1.resolve)(this.labelsFolderPath, this.labelConfig.fileName), this.labels);
+            (0, utils_1.log)(this.exportConfig, 'All the labels have been exported successfully!', 'success');
+        }
+    }
+    async getLabels(skip = 0) {
+        if (skip) {
+            this.qs.skip = skip;
+        }
+        await this.stack
+            .label()
+            .query(this.qs)
+            .find()
+            .then(async (data) => {
+            const { items, count } = data;
+            if (items === null || items === void 0 ? void 0 : items.length) {
+                this.sanitizeAttribs(items);
+                skip += this.labelConfig.limit || 100;
+                if (skip >= count) {
+                    return;
+                }
+                return await this.getLabels(skip);
+            }
+        })
+            .catch((error) => {
+            (0, utils_1.log)(this.exportConfig, `Failed to export labels. ${(0, utils_1.formatError)(error)}`, 'error');
+            (0, utils_1.log)(this.exportConfig, error, 'error');
+        });
+    }
+    sanitizeAttribs(labels) {
+        var _a;
+        for (let index = 0; index < (labels === null || labels === void 0 ? void 0 : labels.length); index++) {
+            const labelUid = labels[index].uid;
+            const labelName = (_a = labels[index]) === null || _a === void 0 ? void 0 : _a.name;
+            this.labels[labelUid] = (0, omit_1.default)(labels[index], this.labelConfig.invalidKeys);
+            (0, utils_1.log)(this.exportConfig, `'${labelName}' label was exported successfully`, 'success');
+        }
+    }
+}
+exports.default = ExportLabels;

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

@@ -0,0 +1,16 @@
+import { ExportConfig, ModuleClassParams } from '../../types';
+import BaseClass from './base-class';
+export default class LocaleExport extends BaseClass {
+    private stackAPIClient;
+    exportConfig: ExportConfig;
+    private masterLocaleConfig;
+    private qs;
+    private localeConfig;
+    private localesPath;
+    private masterLocale;
+    private locales;
+    constructor({ exportConfig, stackAPIClient }: ModuleClassParams);
+    start(): Promise<void>;
+    getLocales(skip?: number): Promise<any>;
+    sanitizeAttribs(locales: Record<string, string>[]): void;
+}

package/lib/export/modules/locales.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const path = tslib_1.__importStar(require("path"));
+const utils_1 = require("../../utils");
+const base_class_1 = tslib_1.__importDefault(require("./base-class"));
+class LocaleExport extends base_class_1.default {
+    constructor({ exportConfig, stackAPIClient }) {
+        super({ exportConfig, stackAPIClient });
+        this.stackAPIClient = stackAPIClient;
+        this.localeConfig = exportConfig.modules.locales;
+        this.masterLocaleConfig = exportConfig.modules.masterLocale;
+        this.qs = {
+            include_count: true,
+            asc: 'updated_at',
+            only: {
+                BASE: this.localeConfig.requiredKeys,
+            },
+        };
+        this.localesPath = path.resolve(exportConfig.data, exportConfig.branchName || '', this.localeConfig.dirName);
+        this.locales = {};
+        this.masterLocale = {};
+    }
+    async start() {
+        try {
+            (0, utils_1.log)(this.exportConfig, 'Starting locale export', 'success');
+            await utils_1.fsUtil.makeDirectory(this.localesPath);
+            await this.getLocales();
+            utils_1.fsUtil.writeFile(path.join(this.localesPath, this.localeConfig.fileName), this.locales);
+            utils_1.fsUtil.writeFile(path.join(this.localesPath, this.masterLocaleConfig.fileName), this.masterLocale);
+            (0, utils_1.log)(this.exportConfig, 'Completed locale export', 'success');
+        }
+        catch (error) {
+            (0, utils_1.log)(this.exportConfig, `Failed to export locales. ${(0, utils_1.formatError)(error)}`, 'error');
+            throw new Error('Failed to export locales');
+        }
+    }
+    async getLocales(skip = 0) {
+        if (skip) {
+            this.qs.skip = skip;
+        }
+        let localesFetchResponse = await this.stackAPIClient.locale().query(this.qs).find();
+        if (Array.isArray(localesFetchResponse.items) && localesFetchResponse.items.length > 0) {
+            this.sanitizeAttribs(localesFetchResponse.items);
+            skip += this.localeConfig.limit || 100;
+            if (skip > localesFetchResponse.count) {
+                return;
+            }
+            return await this.getLocales(skip);
+        }
+    }
+    sanitizeAttribs(locales) {
+        locales.forEach((locale) => {
+            for (let key in locale) {
+                if (this.localeConfig.requiredKeys.indexOf(key) === -1) {
+                    delete locale[key];
+                }
+            }
+            if (locale.code === this.exportConfig.master_locale.code) {
+                this.masterLocale[locale.uid] = locale;
+            }
+            else {
+                this.locales[locale.uid] = locale;
+            }
+        });
+    }
+}
+exports.default = LocaleExport;

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

@@ -0,0 +1,18 @@
+import { NodeCrypto } from '@contentstack/cli-utilities';
+import BaseClass from './base-class';
+import { ModuleClassParams } from '../../types';
+export default class ExportMarketplaceApps extends BaseClass {
+    private httpClient;
+    private marketplaceAppConfig;
+    private listOfApps;
+    private installedApps;
+    developerHubBaseUrl: string;
+    marketplaceAppPath: string;
+    nodeCrypto: NodeCrypto;
+    constructor({ exportConfig, stackAPIClient }: ModuleClassParams);
+    start(): Promise<void>;
+    setHttpClient(): Promise<void>;
+    getAllStackSpecificApps(skip?: number): Promise<any>;
+    exportInstalledExtensions(): Promise<void>;
+    getAppConfigurations(index: number, appInstallation: any): Promise<void>;
+}

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

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const map_1 = tslib_1.__importDefault(require("lodash/map"));
+const has_1 = tslib_1.__importDefault(require("lodash/has"));
+const find_1 = tslib_1.__importDefault(require("lodash/find"));
+const entries_1 = tslib_1.__importDefault(require("lodash/entries"));
+const isEmpty_1 = tslib_1.__importDefault(require("lodash/isEmpty"));
+const node_path_1 = require("node:path");
+const cli_utilities_1 = require("@contentstack/cli-utilities");
+const config_1 = tslib_1.__importDefault(require("../../config"));
+const utils_1 = require("../../utils");
+const base_class_1 = tslib_1.__importDefault(require("./base-class"));
+class ExportMarketplaceApps extends base_class_1.default {
+    constructor({ exportConfig, stackAPIClient }) {
+        super({ exportConfig, stackAPIClient });
+        this.httpClient = new cli_utilities_1.HttpClient();
+        this.marketplaceAppConfig = config_1.default.modules.marketplace_apps;
+        this.listOfApps = [];
+        this.installedApps = [];
+    }
+    async start() {
+        if (!(0, cli_utilities_1.isAuthenticated)()) {
+            cli_utilities_1.cliux.print('WARNING!!! To export Marketplace apps, you must be logged in. Please check csdx auth:login --help to log in', { color: 'yellow' });
+            return Promise.resolve();
+        }
+        (0, utils_1.log)(this.exportConfig, 'Starting marketplace app export', 'info');
+        this.marketplaceAppPath = (0, node_path_1.resolve)(this.exportConfig.data, this.exportConfig.branchName || '', this.marketplaceAppConfig.dirName);
+        await utils_1.fsUtil.makeDirectory(this.marketplaceAppPath);
+        this.developerHubBaseUrl = this.exportConfig.developerHubBaseUrl || (await (0, utils_1.getDeveloperHubUrl)(this.exportConfig));
+        this.exportConfig.org_uid = await (0, utils_1.getOrgUid)(this.exportConfig);
+        await this.setHttpClient();
+        await this.getAllStackSpecificApps();
+        this.installedApps = this.listOfApps;
+        await this.exportInstalledExtensions();
+    }
+    async setHttpClient() {
+        if (!this.exportConfig.auth_token) {
+            this.httpClient = new cli_utilities_1.OauthDecorator(this.httpClient);
+            const headers = await this.httpClient.preHeadersCheck(this.exportConfig);
+            this.httpClient = this.httpClient.headers(headers);
+        }
+        else {
+            this.httpClient = new cli_utilities_1.HttpClientDecorator(this.httpClient);
+            this.httpClient.headers(this.exportConfig);
+        }
+    }
+    async getAllStackSpecificApps(skip = 0) {
+        const data = await (0, utils_1.getStackSpecificApps)({
+            developerHubBaseUrl: this.developerHubBaseUrl,
+            httpClient: this.httpClient,
+            config: this.exportConfig,
+            skip,
+        });
+        const { data: apps, count } = data;
+        if (!this.nodeCrypto && (0, find_1.default)(apps, (app) => (0, isEmpty_1.default)(app.configuration))) {
+            this.nodeCrypto = await (0, utils_1.createNodeCryptoInstance)(this.exportConfig);
+        }
+        const stackApps = (0, map_1.default)(apps, (app) => {
+            if ((0, has_1.default)(app, 'configuration')) {
+                app['configuration'] = this.nodeCrypto.encrypt(app.configuration);
+            }
+            return app;
+        });
+        this.listOfApps = [...this.listOfApps, ...stackApps];
+        if (count - (skip + 50) > 0) {
+            return await this.getAllStackSpecificApps(skip + 50);
+        }
+    }
+    async exportInstalledExtensions() {
+        if ((0, isEmpty_1.default)(this.installedApps)) {
+            (0, utils_1.log)(this.exportConfig, 'No marketplace apps found', 'info');
+        }
+        else {
+            for (const [index, app] of (0, entries_1.default)(this.installedApps)) {
+                await this.getAppConfigurations(+index, app);
+            }
+            utils_1.fsUtil.writeFile((0, node_path_1.resolve)(this.marketplaceAppPath, this.marketplaceAppConfig.fileName), this.installedApps);
+            (0, utils_1.log)(this.exportConfig, 'All the marketplace apps have been exported successfully', 'info');
+        }
+    }
+    async getAppConfigurations(index, appInstallation) {
+        var _a, _b;
+        const sdkClient = await (0, cli_utilities_1.managementSDKClient)({
+            host: this.developerHubBaseUrl.split('://').pop(),
+        });
+        const appName = (_a = appInstallation === null || appInstallation === void 0 ? void 0 : appInstallation.manifest) === null || _a === void 0 ? void 0 : _a.name;
+        (0, utils_1.log)(this.exportConfig, `Exporting ${appName} app and it's config.`, 'info');
+        await sdkClient
+            .organization(this.exportConfig.org_uid)
+            .app((_b = appInstallation === null || appInstallation === void 0 ? void 0 : appInstallation.manifest) === null || _b === void 0 ? void 0 : _b.uid)
+            .installation(appInstallation === null || appInstallation === void 0 ? void 0 : appInstallation.uid)
+            .installationData()
+            .then(async (result) => {
+            const { data, error } = result;
+            if ((0, has_1.default)(data, 'server_configuration')) {
+                if (!this.nodeCrypto && (0, has_1.default)(data, 'server_configuration')) {
+                    this.nodeCrypto = await (0, utils_1.createNodeCryptoInstance)(this.exportConfig);
+                }
+                if (!(0, isEmpty_1.default)(data === null || data === void 0 ? void 0 : data.server_configuration)) {
+                    this.installedApps[index]['server_configuration'] = this.nodeCrypto.encrypt(data.server_configuration);
+                    (0, utils_1.log)(this.exportConfig, `Exported ${appName} app and it's config.`, 'success');
+                }
+                else {
+                    (0, utils_1.log)(this.exportConfig, `Exported ${appName} app`, 'success');
+                }
+            }
+            else if (error) {
+                (0, utils_1.log)(this.exportConfig, `Error on exporting ${appName} app and it's config.`, 'error');
+                (0, utils_1.log)(this.exportConfig, error, 'error');
+            }
+        })
+            .catch((error) => {
+            (0, utils_1.log)(this.exportConfig, `Failed to export ${appName} app config ${(0, utils_1.formatError)(error)}`, 'error');
+            (0, utils_1.log)(this.exportConfig, error, 'error');
+        });
+    }
+}
+exports.default = ExportMarketplaceApps;