@contentstack/cli-cm-export 1.5.9 → 1.6.1

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

@@ -0,0 +1,144 @@
+/*!
+ * Contentstack Export
+ * Copyright (c) 2019 Contentstack LLC
+ * MIT Licensed
+ */
+const _ = require('lodash');
+const path = require('path');
+const chalk = require('chalk');
+const mkdirp = require('mkdirp');
+const eachOf = require('async/eachOf');
+const { cliux, HttpClient, NodeCrypto, managementSDKClient, HttpClientDecorator, OauthDecorator, isAuthenticated, } = require('@contentstack/cli-utilities');
+const { default: config } = require('../../config');
+const { formatError, log, fileHelper } = require('../../utils');
+const { getDeveloperHubUrl } = require('../../utils');
+module.exports = class ExportMarketplaceApps {
+    constructor(credentialConfig) {
+        this.marketplaceAppPath = null;
+        this.developerHubBaseUrl = null;
+        this.marketplaceAppConfig = config.modules.marketplace_apps;
+        this.config = _.merge(config, credentialConfig);
+    }
+    async start() {
+        if (!isAuthenticated()) {
+            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();
+        }
+        this.developerHubBaseUrl = this.config.developerHubBaseUrl || (await getDeveloperHubUrl());
+        await this.getOrgUid();
+        const httpClient = new HttpClient();
+        if (!this.config.auth_token) {
+            this.httpClient = new OauthDecorator(httpClient);
+            const headers = await this.httpClient.preHeadersCheck(this.config);
+            this.httpClient = this.httpClient.headers(headers);
+        }
+        else {
+            this.httpClient = new HttpClientDecorator(httpClient);
+            this.httpClient.headers(this.config);
+        }
+        log(this.config, 'Starting marketplace app export', 'success');
+        this.marketplaceAppPath = path.resolve(this.config.data, this.config.branchName || '', this.marketplaceAppConfig.dirName);
+        mkdirp.sync(this.marketplaceAppPath);
+        return this.exportInstalledExtensions();
+    }
+    async getOrgUid() {
+        const tempAPIClient = await managementSDKClient({ host: this.config.host });
+        const tempStackData = await tempAPIClient
+            .stack({ api_key: this.config.source_stack })
+            .fetch()
+            .catch((error) => {
+            log(this.config, formatError(error), 'error');
+            console.log(error);
+        });
+        if (tempStackData && tempStackData.org_uid) {
+            this.config.org_uid = tempStackData.org_uid;
+        }
+    }
+    async createNodeCryptoInstance() {
+        const cryptoArgs = {};
+        if (this.config.forceStopMarketplaceAppsPrompt) {
+            cryptoArgs['encryptionKey'] = this.config.marketplaceAppEncryptionKey;
+        }
+        else {
+            cryptoArgs['encryptionKey'] = await cliux.inquire({
+                type: 'input',
+                name: 'name',
+                default: this.config.marketplaceAppEncryptionKey,
+                validate: (url) => {
+                    if (!url)
+                        return "Encryption key can't be empty.";
+                    return true;
+                },
+                message: 'Enter marketplace app configurations encryption key',
+            });
+        }
+        this.nodeCrypto = new NodeCrypto(cryptoArgs);
+    }
+    async exportInstalledExtensions() {
+        const client = await managementSDKClient({ host: this.developerHubBaseUrl.split('://').pop() });
+        const installedApps = (await this.getAllStackSpecificApps()) || [];
+        if (!_.isEmpty(installedApps)) {
+            for (const [index, app] of _.entries(installedApps)) {
+                await this.getAppConfigurations(client, installedApps, [+index, app]);
+            }
+            await fileHelper.writeFileSync(path.join(this.marketplaceAppPath, this.marketplaceAppConfig.fileName), installedApps);
+            log(this.config, chalk.green('All the marketplace apps have been exported successfully'), 'success');
+        }
+        else {
+            log(this.config, 'No marketplace apps found', 'success');
+        }
+    }
+    getAllStackSpecificApps(listOfApps = [], skip = 0) {
+        return this.httpClient
+            .get(`${this.developerHubBaseUrl}/installations?target_uids=${this.config.source_stack}&skip=${skip}`)
+            .then(async ({ data }) => {
+            const { data: apps, count } = data;
+            if (!this.nodeCrypto && _.find(apps, (app) => !_.isEmpty(app.configuration))) {
+                await this.createNodeCryptoInstance();
+            }
+            listOfApps.push(..._.map(apps, (app) => {
+                if (_.has(app, 'configuration')) {
+                    app['configuration'] = this.nodeCrypto.encrypt(app.configuration || configuration);
+                }
+                return app;
+            }));
+            if (count - (skip + 50) > 0) {
+                return await this.getAllStackSpecificApps(listOfApps, skip + 50);
+            }
+            return listOfApps;
+        })
+            .catch((error) => {
+            log(this.config, `Failed to export marketplace-apps. ${formatError(error)}`, 'error');
+        });
+    }
+    async getAppConfigurations(sdkClient, installedApps, [index, appInstallation]) {
+        const appName = appInstallation.manifest.name;
+        log(this.config, `Exporting ${appName} app and it's config.`, 'success');
+        await sdkClient
+            .organization(this.config.org_uid)
+            .app(appInstallation.manifest.uid)
+            .installation(appInstallation.uid)
+            .installationData()
+            .then(async (result) => {
+            const { data, error } = result;
+            if (_.has(data, 'server_configuration')) {
+                if (!this.nodeCrypto && _.has(data, 'server_configuration')) {
+                    await this.createNodeCryptoInstance();
+                }
+                if (!_.isEmpty(data.server_configuration)) {
+                    installedApps[index]['server_configuration'] = this.nodeCrypto.encrypt(data.server_configuration);
+                    log(this.config, `Exported ${appName} app and it's config.`, 'success');
+                }
+                else {
+                    log(this.config, `Exported ${appName} app`, 'success');
+                }
+            }
+            else if (error) {
+                log(this.config, `Error on exporting ${appName} app and it's config.`, 'error');
+            }
+        })
+            .catch(err => {
+            log(this.config, `Failed to export ${appName} app config ${formatError(err)}`, 'error');
+        });
+    }
+};

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

@@ -0,0 +1,18 @@
+export = ExportStack;
+declare class ExportStack {
+    constructor(exportConfig: any, stackAPIClient: any);
+    stackConfig: {
+        dirName: string;
+        fileName: string;
+        dependencies?: import("../../types").Modules[];
+    };
+    config: any;
+    stackAPIClient: any;
+    requestOption: {
+        uri: any;
+        headers: any;
+        json: boolean;
+    };
+    start(): Promise<any>;
+    getLocales(apiDetails: any): Promise<any>;
+}

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

@@ -0,0 +1,91 @@
+/*!
+ * Contentstack Export
+ * Copyright (c) 2019 Contentstack LLC
+ * MIT Licensed
+ */
+const path = require('path');
+const mkdirp = require('mkdirp');
+const merge = require('lodash/merge');
+const { default: config } = require('../../config');
+const { managementSDKClient, isAuthenticated } = require('@contentstack/cli-utilities');
+const { log, fileHelper, formatError } = require('../../utils');
+class ExportStack {
+    constructor(exportConfig, stackAPIClient) {
+        this.stackConfig = config.modules.stack;
+        this.config = merge(config, exportConfig);
+        this.stackAPIClient = stackAPIClient;
+        this.requestOption = {
+            uri: this.config.host + this.config.apis.stacks,
+            headers: this.config.headers,
+            json: true,
+        };
+    }
+    async start() {
+        const self = this;
+        if (isAuthenticated()) {
+            const tempAPIClient = await managementSDKClient({ host: config.host });
+            const tempStackData = await tempAPIClient
+                .stack({ api_key: self.config.source_stack })
+                .fetch()
+                .catch((error) => {
+            });
+            if (tempStackData && tempStackData.org_uid) {
+                self.config.org_uid = tempStackData.org_uid;
+                self.config.sourceStackName = tempStackData.name;
+            }
+        }
+        if (!self.config.preserveStackVersion && !self.config.hasOwnProperty('master_locale')) {
+            const apiDetails = {
+                limit: 100,
+                skip: 0,
+                include_count: true,
+            };
+            return self.getLocales(apiDetails);
+        }
+        else if (self.config.preserveStackVersion) {
+            log(self.config, 'Exporting stack details', 'success');
+            let stackFolderPath = path.resolve(self.config.data, stackConfig.dirName);
+            let stackContentsFile = path.resolve(stackFolderPath, stackConfig.fileName);
+            mkdirp.sync(stackFolderPath);
+            return new Promise((resolve, reject) => {
+                return self.stackAPIClient
+                    .fetch()
+                    .then((response) => {
+                    fileHelper.writeFile(stackContentsFile, response);
+                    log(self.config, 'Exported stack details successfully!', 'success');
+                    return resolve(response);
+                })
+                    .catch(reject);
+            });
+        }
+    }
+    getLocales(apiDetails) {
+        const self = this;
+        return new Promise((resolve, reject) => {
+            const result = self.stackAPIClient.locale().query(apiDetails);
+            result
+                .find()
+                .then((response) => {
+                const masterLocalObj = response.items.find((obj) => {
+                    if (obj.fallback_locale === null) {
+                        return obj;
+                    }
+                });
+                apiDetails.skip += apiDetails.limit;
+                if (masterLocalObj) {
+                    return resolve(masterLocalObj);
+                }
+                else if (apiDetails.skip <= response.count) {
+                    return resolve(self.getLocales(apiDetails));
+                }
+                else {
+                    return reject('Master locale not found');
+                }
+            })
+                .catch((error) => {
+                return reject(error);
+            });
+        });
+    }
+}
+module.exports = ExportStack;

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

@@ -0,0 +1,18 @@
+export = ExportWebhooks;
+declare class ExportWebhooks {
+    constructor(exportConfig: any, stackAPIClient: any);
+    config: any;
+    master: {};
+    webhooks: {};
+    requestOptions: {
+        include_count: boolean;
+        asc: string;
+    };
+    webhooksConfig: {
+        dirName: string;
+        fileName: string;
+        dependencies?: import("../../types").Modules[];
+    };
+    stackAPIClient: any;
+    start(): Promise<any>;
+}

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

@@ -0,0 +1,60 @@
+/*!
+ * Contentstack Export
+ * Copyright (c) 2019 Contentstack LLC
+ * MIT Licensed
+ */
+const path = require('path');
+const chalk = require('chalk');
+const mkdirp = require('mkdirp');
+const { merge } = require('lodash');
+const { default: config } = require('../../config');
+const { formatError, log, fileHelper } = require('../../utils');
+// Create folder for environments
+module.exports = class ExportWebhooks {
+    constructor(exportConfig, stackAPIClient) {
+        this.master = {};
+        this.webhooks = {};
+        this.requestOptions = {
+            include_count: true,
+            asc: 'updated_at',
+        };
+        this.webhooksConfig = config.modules.webhooks;
+        this.config = merge(config, exportConfig);
+        this.stackAPIClient = stackAPIClient;
+    }
+    start() {
+        log(this.config, 'Starting webhooks export', 'success');
+        const self = this;
+        const webhooksFolderPath = path.resolve(this.config.data, this.config.branchName || '', self.webhooksConfig.dirName);
+        mkdirp.sync(webhooksFolderPath);
+        return new Promise((resolve, reject) => {
+            self.stackAPIClient
+                .webhook()
+                .fetchAll(self.requestOptions)
+                .then((webhooks) => {
+                if (webhooks.items.length !== 0) {
+                    for (let i = 0, total = webhooks.count; i < total; i++) {
+                        const webUid = webhooks.items[i].uid;
+                        self.master[webUid] = '';
+                        self.webhooks[webUid] = webhooks.items[i];
+                        delete self.webhooks[webUid].uid;
+                        delete self.webhooks[webUid].SYS_ACL;
+                    }
+                    fileHelper.writeFileSync(path.join(webhooksFolderPath, self.webhooksConfig.fileName), self.webhooks);
+                    log(self.config, chalk.green('All the webhooks have been exported successfully'), 'success');
+                    return resolve();
+                }
+                log(self.config, 'No webhooks found', 'success');
+                resolve();
+            })
+                .catch(function (error) {
+                if (error.statusCode === 401) {
+                    log(self.config, 'You are not allowed to export webhooks, Unless you provide email and password in config', 'error');
+                    return resolve();
+                }
+                log(self.config, `Failed to export webhooks. ${formatError(error)}`, 'error');
+                reject('Failed to export webhooks');
+            });
+        });
+    }
+};

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

@@ -0,0 +1,16 @@
+export = ExportWorkFlows;
+declare class ExportWorkFlows {
+    constructor(exportConfig: any, stackAPIClient: any);
+    config: any;
+    workflows: {};
+    workFlowConfig: {
+        dirName: string;
+        fileName: string;
+        invalidKeys: string[];
+        dependencies?: import("../../types").Modules[];
+    };
+    stackAPIClient: any;
+    start(): Promise<any>;
+    getWorkflowRoles(self: any, workflow: any): Promise<void>;
+    getWorkflowsData(self: any, workflows: any): Promise<void>;
+}

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

@@ -0,0 +1,89 @@
+/*!
+ * Contentstack Export
+ * Copyright (c) 2019 Contentstack LLC
+ * MIT Licensed
+ */
+const path = require('path');
+const chalk = require('chalk');
+const mkdirp = require('mkdirp');
+const { merge } = require('lodash');
+const { formatError, log, fileHelper } = require('../../utils');
+const { default: config } = require('../../config');
+module.exports = class ExportWorkFlows {
+    constructor(exportConfig, stackAPIClient) {
+        this.workflows = {};
+        this.workFlowConfig = config.modules.workflows;
+        this.config = merge(config, exportConfig);
+        this.stackAPIClient = stackAPIClient;
+    }
+    start() {
+        log(this.config, 'Starting workflow export', 'success');
+        const self = this;
+        const workflowsFolderPath = path.resolve(this.config.data, this.config.branchName || '', this.workFlowConfig.dirName);
+        mkdirp.sync(workflowsFolderPath);
+        return new Promise(function (resolve, reject) {
+            return self.stackAPIClient
+                .workflow()
+                .fetchAll()
+                .then(async (response) => {
+                try {
+                    if (response.items.length) {
+                        await self.getWorkflowsData(self, response.items);
+                        log(self.config, chalk.green('All the workflow have been exported successfully'), 'success');
+                    }
+                    if (!response.items.length) {
+                        log(self.config, 'No workflow were found in the Stack', 'success');
+                    }
+                    fileHelper.writeFileSync(path.join(workflowsFolderPath, self.workFlowConfig.fileName), self.workflows);
+                    resolve();
+                }
+                catch (error) {
+                    log(self.config, formatError(error), 'error');
+                    reject(error);
+                }
+            })
+                .catch(function (error) {
+                if (error.statusCode === 401) {
+                    log(self.config, 'You are not allowed to export workflow, Unless you provide email and password in config', 'error');
+                    return resolve();
+                }
+                log(self.config, formatError(error), 'error');
+                resolve();
+            });
+        });
+    }
+    async getWorkflowRoles(self, workflow) {
+        try {
+            for (const stage of workflow.workflow_stages) {
+                if (stage.SYS_ACL.roles.uids.length) {
+                    for (let i = 0; i < stage.SYS_ACL.roles.uids.length; i++) {
+                        const roleUid = stage.SYS_ACL.roles.uids[i];
+                        const roleData = await self.stackAPIClient
+                            .role(roleUid)
+                            .fetch({ include_rules: true, include_permissions: true });
+                        stage.SYS_ACL.roles.uids[i] = roleData;
+                    }
+                }
+            }
+        }
+        catch (error) {
+            log(self.config, `Error fetching roles in export workflows task. ${formatError(error)}`, 'error');
+            throw new Error({ message: 'Error fetching roles in export workflows task.' });
+        }
+    }
+    async getWorkflowsData(self, workflows) {
+        try {
+            for (const workflow of workflows) {
+                log(self.config, workflow.name + ' workflow was exported successfully', 'success');
+                await self.getWorkflowRoles(self, workflow);
+                self.workflows[workflow.uid] = workflow;
+                const deleteItems = config.modules.workflows.invalidKeys;
+                deleteItems.forEach((e) => delete workflow[e]);
+            }
+        }
+        catch (error) {
+            log(self.config, `Error fetching workflow data in export workflows task. ${formatError(error)}`, 'error');
+            throw error;
+        }
+    }
+};

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

@@ -0,0 +1,158 @@
+import { Modules } from '.';
+export default interface DefaultConfig {
+    versioning: boolean;
+    host: string;
+    cdn?: string;
+    developerHubUrls: any;
+    modules: {
+        types: Modules[];
+        locales: {
+            dirName: string;
+            fileName: string;
+            requiredKeys: string[];
+            dependencies?: Modules[];
+        };
+        customRoles: {
+            dirName: string;
+            fileName: string;
+            customRolesLocalesFileName: string;
+            dependencies?: Modules[];
+        };
+        'custom-roles': {
+            dirName: string;
+            fileName: string;
+            customRolesLocalesFileName: string;
+            dependencies?: Modules[];
+        };
+        environments: {
+            dirName: string;
+            fileName: string;
+            dependencies?: Modules[];
+        };
+        labels: {
+            dirName: string;
+            fileName: string;
+            invalidKeys: string[];
+            dependencies?: Modules[];
+        };
+        webhooks: {
+            dirName: string;
+            fileName: string;
+            dependencies?: Modules[];
+        };
+        releases: {
+            dirName: string;
+            fileName: string;
+            releasesList: string;
+            invalidKeys: string[];
+            dependencies?: Modules[];
+        };
+        workflows: {
+            dirName: string;
+            fileName: string;
+            invalidKeys: string[];
+            dependencies?: Modules[];
+        };
+        globalfields: {
+            dirName: string;
+            fileName: string;
+            validKeys: string[];
+            dependencies?: Modules[];
+        };
+        'global-fields': {
+            dirName: string;
+            fileName: string;
+            validKeys: string[];
+            dependencies?: Modules[];
+        };
+        assets: {
+            dirName: string;
+            fileName: string;
+            batchLimit: number;
+            host: string;
+            invalidKeys: string[];
+            chunkFileSize: number;
+            downloadLimit: number;
+            fetchConcurrency: number;
+            assetsMetaKeys: string[];
+            securedAssets: boolean;
+            displayExecutionTime: boolean;
+            enableDownloadStatus: boolean;
+            includeVersionedAssets: boolean;
+            dependencies?: Modules[];
+        };
+        content_types: {
+            dirName: string;
+            fileName: string;
+            validKeys: string[];
+            limit: number;
+            dependencies?: Modules[];
+        };
+        'content-types': {
+            dirName: string;
+            fileName: string;
+            validKeys: string[];
+            limit: number;
+            dependencies?: Modules[];
+        };
+        entries: {
+            dirName: string;
+            fileName: string;
+            invalidKeys: string[];
+            batchLimit: number;
+            downloadLimit: number;
+            limit: number;
+            dependencies?: Modules[];
+        };
+        extensions: {
+            dirName: string;
+            fileName: string;
+            dependencies?: Modules[];
+        };
+        stack: {
+            dirName: string;
+            fileName: string;
+            dependencies?: Modules[];
+        };
+        dependency: {
+            entries: string[];
+        };
+        marketplace_apps: {
+            dirName: string;
+            fileName: string;
+            dependencies?: Modules[];
+        };
+        'marketplace-apps': {
+            dirName: string;
+            fileName: string;
+            dependencies?: Modules[];
+        };
+        masterLocale: {
+            dirName: string;
+            fileName: string;
+            requiredKeys: string[];
+        };
+    };
+    languagesCode: string[];
+    updatedModules: string[];
+    apis: {
+        userSession: string;
+        globalfields: string;
+        locales: string;
+        labels: string;
+        environments: string;
+        assets: string;
+        content_types: string;
+        entries: string;
+        users: string;
+        extension: string;
+        webhooks: string;
+        stacks: string;
+    };
+    preserveStackVersion: boolean;
+    fetchConcurrency: number;
+    writeConcurrency: number;
+    developerHubBaseUrl: string;
+    marketplaceAppEncryptionKey: string;
+    useNewModuleStructure: boolean;
+}

package/lib/types/default-config.js

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

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

@@ -0,0 +1,34 @@
+import { Modules } from '.';
+import DefaultConfig from './default-config';
+export default interface ExportConfig extends DefaultConfig {
+    exportDir: string;
+    data: string;
+    management_token?: string;
+    apiKey: string;
+    forceStopMarketplaceAppsPrompt: boolean;
+    auth_token?: string;
+    branchName?: string;
+    securedAssets?: boolean;
+    contentTypes?: string[];
+    branches?: branch[];
+    branchEnabled?: boolean;
+    branchDir?: string;
+    singleModuleExport?: boolean;
+    moduleName?: Modules;
+    master_locale: masterLocale;
+    headers?: {
+        api_key: string;
+        access_token?: string;
+        authtoken?: string;
+        'X-User-Agent': string;
+    };
+    access_token?: string;
+}
+type branch = {
+    uid: string;
+    source: string;
+};
+type masterLocale = {
+    code: string;
+};
+export {};

package/lib/types/export-config.js

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

package/lib/types/index.d.ts

@@ -0,0 +1,45 @@
+import { ContentstackClient } from '@contentstack/cli-utilities';
+import ExportConfig from './export-config';
+export interface AuthOptions {
+    contentstackClient: any;
+}
+export interface ContentStackManagementClient {
+    contentstackClient: object;
+}
+export interface PrintOptions {
+    color?: string;
+}
+export interface InquirePayload {
+    type: string;
+    name: string;
+    message: string;
+    choices?: Array<any>;
+    transformer?: Function;
+}
+export interface User {
+    email: string;
+    authtoken: string;
+}
+export type Modules = 'stack' | 'assets' | 'locales' | 'environments' | 'extensions' | 'webhooks' | 'global-fields' | 'entries' | 'content-types' | 'custom-roles' | 'workflows' | 'labels' | 'marketplace-apps';
+export type ModuleClassParams = {
+    stackAPIClient: ReturnType<ContentstackClient['stack']>;
+    exportConfig: ExportConfig;
+    moduleName: Modules;
+};
+export interface ExternalConfig extends ExportConfig {
+    master_locale: {
+        name: string;
+        code: string;
+    };
+    source_stack?: string;
+    data: string;
+    branchName: string;
+    moduleName: Modules;
+    fetchConcurrency: number;
+    writeConcurrency: number;
+    securedAssets: boolean;
+    email?: string;
+    password?: string;
+}
+export { default as DefaultConfig } from './default-config';
+export { default as ExportConfig } from './export-config';