@contentstack/cli-cm-export 1.6.1 → 1.8.0

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/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.js

@@ -51,12 +51,13 @@ class LocaleExport extends base_class_1.default {
     }
     sanitizeAttribs(locales) {
         locales.forEach((locale) => {
+            var _a, _b;
             for (let key in locale) {
                 if (this.localeConfig.requiredKeys.indexOf(key) === -1) {
                     delete locale[key];
                 }
             }
-            if (locale.code === this.exportConfig.master_locale.code) {
+            if ((locale === null || locale === void 0 ? void 0 : locale.code) === ((_b = (_a = this.exportConfig) === null || _a === void 0 ? void 0 : _a.master_locale) === null || _b === void 0 ? void 0 : _b.code)) {
                 this.masterLocale[locale.uid] = locale;
             }
             else {

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;

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

@@ -0,0 +1,12 @@
+import BaseClass from './base-class';
+import { ModuleClassParams } from '../../types';
+export default class ExportStack extends BaseClass {
+    private stackConfig;
+    private stackFolderPath;
+    private qs;
+    constructor({ exportConfig, stackAPIClient }: ModuleClassParams);
+    start(): Promise<void>;
+    getStack(): Promise<any>;
+    getLocales(skip?: number): Promise<any>;
+    exportStack(): Promise<any>;
+}

package/lib/export/modules/stack.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const find_1 = tslib_1.__importDefault(require("lodash/find"));
+const node_path_1 = require("node:path");
+const cli_utilities_1 = require("@contentstack/cli-utilities");
+const config_1 = tslib_1.__importDefault(require("../../config"));
+const base_class_1 = tslib_1.__importDefault(require("./base-class"));
+const utils_1 = require("../../utils");
+class ExportStack extends base_class_1.default {
+    constructor({ exportConfig, stackAPIClient }) {
+        super({ exportConfig, stackAPIClient });
+        this.stackConfig = config_1.default.modules.stack;
+        this.qs = { include_count: true };
+        this.stackFolderPath = (0, node_path_1.resolve)(this.exportConfig.data, this.stackConfig.dirName);
+    }
+    async start() {
+        if ((0, cli_utilities_1.isAuthenticated)()) {
+            const stackData = await this.getStack();
+            if (stackData === null || stackData === void 0 ? void 0 : stackData.org_uid) {
+                this.exportConfig.org_uid = stackData.org_uid;
+                this.exportConfig.sourceStackName = stackData.name;
+            }
+        }
+        if (!this.exportConfig.preserveStackVersion && !this.exportConfig.hasOwnProperty('master_locale')) {
+            //fetch master locale details
+            return this.getLocales();
+        }
+        else if (this.exportConfig.preserveStackVersion) {
+            return this.exportStack();
+        }
+    }
+    async getStack() {
+        const tempAPIClient = await (0, cli_utilities_1.managementSDKClient)({ host: this.exportConfig.host });
+        return await tempAPIClient
+            .stack({ api_key: this.exportConfig.source_stack })
+            .fetch()
+            .catch((error) => {
+            (0, utils_1.log)(this.exportConfig, `Failed to export stack. ${(0, utils_1.formatError)(error)}`, 'error');
+        });
+    }
+    async getLocales(skip = 0) {
+        if (skip) {
+            this.qs.skip = skip;
+        }
+        return await this.stack
+            .locale()
+            .query(this.qs)
+            .find()
+            .then(async (data) => {
+            const { items, count } = data;
+            if (items === null || items === void 0 ? void 0 : items.length) {
+                skip += this.stackConfig.limit || 100;
+                const masterLocalObj = (0, find_1.default)(items, (locale) => {
+                    if (locale.fallback_locale === null) {
+                        return locale;
+                    }
+                });
+                if (masterLocalObj) {
+                    return masterLocalObj;
+                }
+                else if (skip >= count) {
+                    (0, utils_1.log)(this.exportConfig, 'Master locale not found', 'error');
+                    return;
+                }
+                else {
+                    return await this.getLocales(skip);
+                }
+            }
+        })
+            .catch((error) => {
+            (0, utils_1.log)(this.exportConfig, `Failed to export locales. ${(0, utils_1.formatError)(error)}`, 'error');
+            (0, utils_1.log)(this.exportConfig, error, 'error');
+        });
+    }
+    async exportStack() {
+        (0, utils_1.log)(this.exportConfig, 'Exporting stack details', 'success');
+        await utils_1.fsUtil.makeDirectory(this.stackFolderPath);
+        return this.stack
+            .fetch()
+            .then((resp) => {
+            utils_1.fsUtil.writeFile((0, node_path_1.resolve)(this.stackFolderPath, this.stackConfig.fileName), resp);
+            (0, utils_1.log)(this.exportConfig, 'Exported stack details successfully!', 'success');
+            return resp;
+        })
+            .catch((error) => {
+            (0, utils_1.log)(this.exportConfig, `Failed to export stack. ${(0, utils_1.formatError)(error)}`, 'error');
+        });
+    }
+}
+exports.default = ExportStack;

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

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

package/lib/export/modules/webhooks.js

@@ -0,0 +1,63 @@
+"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 ExportWebhooks extends base_class_1.default {
+    constructor({ exportConfig, stackAPIClient }) {
+        super({ exportConfig, stackAPIClient });
+        this.webhooks = {};
+        this.webhookConfig = config_1.default.modules.webhooks;
+        this.qs = { include_count: true, asc: 'updated_at' };
+    }
+    async start() {
+        (0, utils_1.log)(this.exportConfig, 'Starting webhooks export', 'info');
+        this.webhooksFolderPath = (0, node_path_1.resolve)(this.exportConfig.data, this.exportConfig.branchName || '', this.webhookConfig.dirName);
+        await utils_1.fsUtil.makeDirectory(this.webhooksFolderPath);
+        await this.getWebhooks();
+        if (this.webhooks === undefined || (0, isEmpty_1.default)(this.webhooks)) {
+            (0, utils_1.log)(this.exportConfig, 'No webhooks found', 'info');
+        }
+        else {
+            utils_1.fsUtil.writeFile((0, node_path_1.resolve)(this.webhooksFolderPath, this.webhookConfig.fileName), this.webhooks);
+            (0, utils_1.log)(this.exportConfig, 'All the webhooks have been exported successfully!', 'success');
+        }
+    }
+    async getWebhooks(skip = 0) {
+        if (skip) {
+            this.qs.skip = skip;
+        }
+        await this.stack
+            .webhook()
+            .fetchAll(this.qs)
+            .then(async (data) => {
+            const { items, count } = data;
+            if (items === null || items === void 0 ? void 0 : items.length) {
+                this.sanitizeAttribs(items);
+                skip += this.webhookConfig.limit || 100;
+                if (skip >= count) {
+                    return;
+                }
+                return await this.getWebhooks(skip);
+            }
+        })
+            .catch((error) => {
+            (0, utils_1.log)(this.exportConfig, `Failed to export webhooks.${(0, utils_1.formatError)(error)}`, 'error');
+            (0, utils_1.log)(this.exportConfig, error, 'error');
+        });
+    }
+    sanitizeAttribs(webhooks) {
+        var _a;
+        for (let index = 0; index < (webhooks === null || webhooks === void 0 ? void 0 : webhooks.length); index++) {
+            const webhookUid = webhooks[index].uid;
+            const webhookName = (_a = webhooks[index]) === null || _a === void 0 ? void 0 : _a.name;
+            this.webhooks[webhookUid] = (0, omit_1.default)(webhooks[index], ['SYS_ACL']);
+            (0, utils_1.log)(this.exportConfig, `'${webhookName}' webhook was exported successfully`, 'success');
+        }
+    }
+}
+exports.default = ExportWebhooks;

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

@@ -0,0 +1,14 @@
+import BaseClass from './base-class';
+import { ModuleClassParams } from '../../types';
+export default class ExportWorkFlows extends BaseClass {
+    private workflows;
+    private workflowConfig;
+    webhooksFolderPath: string;
+    private qs;
+    constructor({ exportConfig, stackAPIClient }: ModuleClassParams);
+    start(): Promise<void>;
+    getWorkflows(skip?: number): Promise<void>;
+    sanitizeAttribs(workflows: Record<string, string>[]): Promise<void>;
+    getWorkflowRoles(workflow: Record<string, any>): Promise<void>;
+    getRoles(roleUid: number): Promise<any>;
+}

package/lib/export/modules/workflows.js

@@ -0,0 +1,81 @@
+"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 ExportWorkFlows extends base_class_1.default {
+    constructor({ exportConfig, stackAPIClient }) {
+        super({ exportConfig, stackAPIClient });
+        this.workflows = {};
+        this.workflowConfig = config_1.default.modules.workflows;
+        this.qs = { include_count: true };
+    }
+    async start() {
+        (0, utils_1.log)(this.exportConfig, 'Starting workflows export', 'info');
+        this.webhooksFolderPath = (0, node_path_1.resolve)(this.exportConfig.data, this.exportConfig.branchName || '', this.workflowConfig.dirName);
+        await utils_1.fsUtil.makeDirectory(this.webhooksFolderPath);
+        await this.getWorkflows();
+        if (this.workflows === undefined || (0, isEmpty_1.default)(this.workflows)) {
+            (0, utils_1.log)(this.exportConfig, 'No workflows found', 'info');
+        }
+        else {
+            utils_1.fsUtil.writeFile((0, node_path_1.resolve)(this.webhooksFolderPath, this.workflowConfig.fileName), this.workflows);
+            (0, utils_1.log)(this.exportConfig, 'All the workflows have been exported successfully!', 'success');
+        }
+    }
+    async getWorkflows(skip = 0) {
+        if (skip) {
+            this.qs.skip = skip;
+        }
+        await this.stack
+            .workflow()
+            .fetchAll(this.qs)
+            .then(async (data) => {
+            const { items, count } = data;
+            if (items === null || items === void 0 ? void 0 : items.length) {
+                await this.sanitizeAttribs(items);
+                skip += this.workflowConfig.limit || 100;
+                if (skip >= count) {
+                    return;
+                }
+                return await this.getWorkflows(skip);
+            }
+        })
+            .catch((error) => {
+            (0, utils_1.log)(this.exportConfig, `Failed to export workflows.${(0, utils_1.formatError)(error)}`, 'error');
+            (0, utils_1.log)(this.exportConfig, error, 'error');
+        });
+    }
+    async sanitizeAttribs(workflows) {
+        var _a;
+        for (let index = 0; index < (workflows === null || workflows === void 0 ? void 0 : workflows.length); index++) {
+            await this.getWorkflowRoles(workflows[index]);
+            const workflowUid = workflows[index].uid;
+            const workflowName = ((_a = workflows[index]) === null || _a === void 0 ? void 0 : _a.name) || '';
+            this.workflows[workflowUid] = (0, omit_1.default)(workflows[index], this.workflowConfig.invalidKeys);
+            (0, utils_1.log)(this.exportConfig, `'${workflowName}' workflow was exported successfully`, 'success');
+        }
+    }
+    async getWorkflowRoles(workflow) {
+        var _a, _b, _c;
+        for (const stage of workflow === null || workflow === void 0 ? void 0 : workflow.workflow_stages) {
+            for (let i = 0; i < ((_c = (_b = (_a = stage === null || stage === void 0 ? void 0 : stage.SYS_ACL) === null || _a === void 0 ? void 0 : _a.roles) === null || _b === void 0 ? void 0 : _b.uids) === null || _c === void 0 ? void 0 : _c.length); i++) {
+                const roleUid = stage.SYS_ACL.roles.uids[i];
+                const roleData = await this.getRoles(roleUid);
+                stage.SYS_ACL.roles.uids[i] = roleData;
+            }
+        }
+    }
+    async getRoles(roleUid) {
+        return await this.stack
+            .role(roleUid)
+            .fetch({ 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'));
+    }
+}
+exports.default = ExportWorkFlows;

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

@@ -1,5 +1,6 @@
 const path = require('path');
 const chalk = require('chalk');
+const { values } = require('lodash');
 const { executeTask, formatError, fileHelper, log } = require('../../utils');
 class EntriesExport {
     constructor(exportConfig, stackAPIClient) {
@@ -31,7 +32,7 @@ class EntriesExport {
                 log(this.exportConfig, `Exported entries of type '${requestOption.content_type}' locale '${requestOption.locale}'`, 'success');
                 if (this.exportConfig.versioning) {
                     log(this.exportConfig, `Started export versioned entries of type '${requestOption.content_type}' locale '${requestOption.locale}'`, 'info');
-                    for (let entry of entries) {
+                    for (let entry of values(entries)) {
                         const versionedEntries = await this.getEntryByVersion(Object.assign(Object.assign({}, requestOption), { uid: entry.uid }), entry._version);
                         let versionedEntryPath = path.join(this.entriesRootPath, requestOption.locale, requestOption.content_type, entry.uid);
                         await fileHelper.makeDirectory(versionedEntryPath);

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

@@ -1 +1,2 @@
-export default function startModuleExport(modulePayload: any): Promise<any>;
+export = startModuleExport;
+declare function startModuleExport(modulePayload: any): Promise<any>;

package/lib/export/modules-js/index.js

@@ -1,4 +1,3 @@
-"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);
@@ -22,12 +21,11 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var _a;
-Object.defineProperty(exports, "__esModule", { value: true });
 async function startModuleExport(modulePayload) {
+    var _a;
     const { moduleName, exportConfig, stackAPIClient } = modulePayload;
-    const { default: ModuleRunner } = await (_a = `./${moduleName}`, Promise.resolve().then(() => __importStar(require(_a))));
+    const { default: ModuleRunner } = await (_a = `./${moduleName}.js`, Promise.resolve().then(() => __importStar(require(_a))));
     const moduleRunner = new ModuleRunner(exportConfig, stackAPIClient);
     return moduleRunner.start();
 }
-exports.default = startModuleExport;
+module.exports = startModuleExport;

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

@@ -14,7 +14,6 @@ declare class ExportMarketplaceApps {
     };
     start(): Promise<void>;
     getOrgUid(): Promise<void>;
-    createNodeCryptoInstance(): Promise<void>;
     exportInstalledExtensions(): Promise<void>;
     getAllStackSpecificApps(listOfApps?: any[], skip?: number): any;
     getAppConfigurations(sdkClient: any, installedApps: any, [index, appInstallation]: [any, any]): Promise<void>;