@contentstack/cli-cm-export 1.7.0 → 1.8.1

package/README.md

@@ -48,7 +48,7 @@ $ npm install -g @contentstack/cli-cm-export
 $ csdx COMMAND
 running command...
 $ csdx (--version)
-@contentstack/cli-cm-export/1.7.0 linux-x64 node-v18.17.0
+@contentstack/cli-cm-export/1.8.1 linux-x64 node-v18.17.1
 $ csdx --help [COMMAND]
 USAGE
   $ csdx COMMAND

package/lib/config/index.js

@@ -137,6 +137,7 @@ const config = {
             // total no of entries fetched in each content type in a single call
             limit: 100,
             dependencies: ['locales', 'content-types'],
+            exportVersions: false,
         },
         extensions: {
             dirName: 'extensions',
@@ -378,6 +379,9 @@ const config = {
         'custom-roles',
         'global-fields',
         'content-types',
+        'entries',
+        'workflows',
+        'stack',
     ],
     apis: {
         userSession: '/user-session/',

package/lib/export/modules/base-class.d.ts

@@ -18,11 +18,12 @@ export type EnvType = {
 export type CustomPromiseHandlerInput = {
     index: number;
     batchIndex: number;
+    element?: Record<string, any>;
     apiParams?: ApiOptions;
     isLastRequest: boolean;
 };
 export type CustomPromiseHandler = (input: CustomPromiseHandlerInput) => Promise<any>;
-export type ApiModuleType = 'stack' | 'asset' | 'assets' | 'entry' | 'entries' | 'content-type' | 'content-types' | 'stacks' | 'download-asset';
+export type ApiModuleType = 'stack' | 'asset' | 'assets' | 'entry' | 'entries' | 'content-type' | 'content-types' | 'stacks' | 'versioned-entries' | 'download-asset';
 export default abstract class BaseClass {
     readonly client: any;
     exportConfig: ExportConfig;

package/lib/export/modules/base-class.js

@@ -45,6 +45,7 @@ class BaseClass {
                     if (promisifyHandler instanceof Function) {
                         promise = promisifyHandler({
                             apiParams,
+                            element,
                             isLastRequest,
                             index: Number(index),
                             batchIndex: Number(batchIndex),

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

@@ -0,0 +1,26 @@
+import { ExportConfig, ModuleClassParams } from '../../types';
+import BaseClass, { ApiOptions } from './base-class';
+export default class EntriesExport extends BaseClass {
+    private stackAPIClient;
+    exportConfig: ExportConfig;
+    private entriesConfig;
+    private entriesDirPath;
+    private localesFilePath;
+    private schemaFilePath;
+    private entriesFileHelper;
+    constructor({ exportConfig, stackAPIClient }: ModuleClassParams);
+    start(): Promise<void>;
+    createRequestObjects(locales: Array<Record<string, unknown>>, contentTypes: Array<Record<string, unknown>>): Array<Record<string, any>>;
+    getEntries(options: Record<string, any>): Promise<any>;
+    fetchEntriesVersions(entries: any, options: {
+        locale: string;
+        contentType: string;
+        versionedEntryPath: string;
+    }): Promise<void>;
+    entryVersionHandler({ apiParams, element: entry, }: {
+        apiParams: ApiOptions;
+        element: Record<string, string>;
+        isLastRequest: boolean;
+    }): Promise<unknown>;
+    getEntryByVersion(options: any, entry: Record<string, any>, entries?: Array<Record<string, any>>): Promise<any[]>;
+}

package/lib/export/modules/entries.js

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const path = tslib_1.__importStar(require("path"));
+const cli_utilities_1 = require("@contentstack/cli-utilities");
+const utils_1 = require("../../utils");
+const base_class_1 = tslib_1.__importDefault(require("./base-class"));
+class EntriesExport extends base_class_1.default {
+    constructor({ exportConfig, stackAPIClient }) {
+        super({ exportConfig, stackAPIClient });
+        this.stackAPIClient = stackAPIClient;
+        this.exportConfig = exportConfig;
+        this.entriesConfig = exportConfig.modules.entries;
+        this.entriesDirPath = path.resolve(exportConfig.data, exportConfig.branchName || '', this.entriesConfig.dirName);
+        this.localesFilePath = path.resolve(exportConfig.data, exportConfig.branchName || '', exportConfig.modules.locales.dirName, exportConfig.modules.locales.fileName);
+        this.schemaFilePath = path.resolve(exportConfig.data, exportConfig.branchName || '', exportConfig.modules.content_types.dirName, 'schema.json');
+    }
+    async start() {
+        var _a;
+        try {
+            (0, utils_1.log)(this.exportConfig, 'Starting entries export', 'info');
+            const locales = utils_1.fsUtil.readFile(this.localesFilePath);
+            const contentTypes = utils_1.fsUtil.readFile(this.schemaFilePath);
+            if (contentTypes.length === 0) {
+                (0, utils_1.log)(this.exportConfig, 'No content types found to export entries', 'info');
+                return;
+            }
+            const entryRequestOptions = this.createRequestObjects(locales, contentTypes);
+            for (let entryRequestOption of entryRequestOptions) {
+                (0, utils_1.log)(this.exportConfig, `Starting export of entries of content type - ${entryRequestOption.contentType} locale - ${entryRequestOption.locale}`, 'info');
+                await this.getEntries(entryRequestOption);
+                (_a = this.entriesFileHelper) === null || _a === void 0 ? void 0 : _a.completeFile(true);
+                (0, utils_1.log)(this.exportConfig, `Exported entries of type '${entryRequestOption.contentType}' locale '${entryRequestOption.locale}'`, 'success');
+            }
+            (0, utils_1.log)(this.exportConfig, 'Entries exported successfully', 'success');
+        }
+        catch (error) {
+            (0, utils_1.log)(this.exportConfig, `Failed to export entries ${(0, utils_1.formatError)(error)}`, 'error');
+            throw new Error('Failed to export entries');
+        }
+    }
+    createRequestObjects(locales, contentTypes) {
+        let requestObjects = [];
+        contentTypes.forEach((contentType) => {
+            if (Object.keys(locales).length !== 0) {
+                for (let locale in locales) {
+                    requestObjects.push({
+                        contentType: contentType.uid,
+                        locale: locales[locale].code,
+                    });
+                }
+            }
+            requestObjects.push({
+                contentType: contentType.uid,
+                locale: this.exportConfig.master_locale.code,
+            });
+        });
+        return requestObjects;
+    }
+    async getEntries(options) {
+        options.skip = options.skip || 0;
+        let requestObject = {
+            locale: options.locale,
+            skip: options.skip,
+            limit: this.entriesConfig.limit,
+            include_count: true,
+            include_publish_details: true,
+            query: {
+                locale: options.locale,
+            },
+        };
+        const entriesSearchResponse = await this.stackAPIClient
+            .contentType(options.contentType)
+            .entry()
+            .query(requestObject)
+            .find();
+        if (Array.isArray(entriesSearchResponse.items) && entriesSearchResponse.items.length > 0) {
+            if (options.skip === 0) {
+                const entryBasePath = path.join(this.entriesDirPath, options.contentType, options.locale);
+                await utils_1.fsUtil.makeDirectory(entryBasePath);
+                this.entriesFileHelper = new cli_utilities_1.FsUtility({
+                    moduleName: 'entries',
+                    indexFileName: 'index.json',
+                    basePath: entryBasePath,
+                    chunkFileSize: this.entriesConfig.chunkFileSize,
+                    keepMetadata: false,
+                    omitKeys: this.entriesConfig.invalidKeys,
+                });
+            }
+            this.entriesFileHelper.writeIntoFile(entriesSearchResponse.items, { mapKeyVal: true });
+            if (this.entriesConfig.exportVersions) {
+                let versionedEntryPath = path.join(this.entriesDirPath, options.contentType, options.locale, 'versions');
+                utils_1.fsUtil.makeDirectory(versionedEntryPath);
+                await this.fetchEntriesVersions(entriesSearchResponse.items, {
+                    locale: options.locale,
+                    contentType: options.contentType,
+                    versionedEntryPath,
+                });
+            }
+            options.skip += this.entriesConfig.limit || 100;
+            if (options.skip >= entriesSearchResponse.count) {
+                return Promise.resolve(true);
+            }
+            return await this.getEntries(options);
+        }
+    }
+    async fetchEntriesVersions(entries, options) {
+        const onSuccess = ({ response, apiData: entry }) => {
+            utils_1.fsUtil.writeFile(path.join(options.versionedEntryPath, `${entry.uid}.json`), response);
+            (0, utils_1.log)(this.exportConfig, `Exported versioned entries of type '${options.contentType}' locale '${options.locale}'`, 'success');
+        };
+        const onReject = ({ error, apiData: { uid } = undefined }) => {
+            (0, utils_1.log)(this.exportConfig, `failed to export versions of entry ${uid}`, 'error');
+            (0, utils_1.log)(this.exportConfig, (0, utils_1.formatError)(error), 'error');
+        };
+        return await this.makeConcurrentCall({
+            apiBatches: [entries],
+            module: 'versioned-entries',
+            totalCount: entries.length,
+            concurrencyLimit: this.entriesConfig.batchLimit,
+            apiParams: {
+                module: 'versioned-entries',
+                queryParam: options,
+                resolve: onSuccess,
+                reject: onReject,
+            },
+        }, this.entryVersionHandler.bind(this));
+    }
+    async entryVersionHandler({ apiParams, element: entry, }) {
+        return new Promise(async (resolve, reject) => {
+            return await this.getEntryByVersion(apiParams.queryParam, entry)
+                .then((response) => {
+                apiParams.resolve({
+                    response,
+                    apiData: entry,
+                });
+                resolve(true);
+            })
+                .catch((error) => {
+                apiParams.reject({
+                    error,
+                    apiData: entry,
+                });
+                reject(true);
+            });
+        });
+    }
+    async getEntryByVersion(options, entry, entries = []) {
+        const queryRequestObject = {
+            locale: options.locale,
+            except: {
+                BASE: this.entriesConfig.invalidKeys,
+            },
+            version: entry._version,
+        };
+        const entryResponse = await this.stackAPIClient
+            .contentType(options.contentType)
+            .entry(entry.uid)
+            .fetch(queryRequestObject);
+        entries.push(entryResponse);
+        if (--entry._version > 0) {
+            return await this.getEntryByVersion(options, entry, entries);
+        }
+        return entries;
+    }
+}
+exports.default = EntriesExport;

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

@@ -45,7 +45,7 @@ class ExportWebhooks extends base_class_1.default {
                 return await this.getWebhooks(skip);
             }
         })
-            .catch(({ error }) => {
+            .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');
         });

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

@@ -44,8 +44,8 @@ class ExportStack {
         }
         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);
+            let stackFolderPath = path.resolve(self.config.data, this.stackConfig.dirName);
+            let stackContentsFile = path.resolve(stackFolderPath, this.stackConfig.fileName);
             mkdirp.sync(stackFolderPath);
             return new Promise((resolve, reject) => {
                 return self.stackAPIClient

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

@@ -103,6 +103,7 @@ export default interface DefaultConfig {
             downloadLimit: number;
             limit: number;
             dependencies?: Modules[];
+            exportVersions: boolean;
         };
         extensions: {
             dirName: string;

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

@@ -25,6 +25,7 @@ export default interface ExportConfig extends DefaultConfig {
     access_token?: string;
     org_uid?: string;
     source_stack?: string;
+    sourceStackName?: string;
 }
 type branch = {
     uid: string;

package/lib/types/index.d.ts

@@ -84,5 +84,11 @@ export interface CustomRoleConfig {
     customRolesLocalesFileName: string;
     dependencies?: Modules[];
 }
+export interface StackConfig {
+    dirName: string;
+    fileName: string;
+    dependencies?: Modules[];
+    limit?: number;
+}
 export { default as DefaultConfig } from './default-config';
 export { default as ExportConfig } from './export-config';

package/oclif.manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.7.0",
+  "version": "1.8.1",
   "commands": {
     "cm:stacks:export": {
       "id": "cm:stacks:export",

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@contentstack/cli-cm-export",
   "description": "Contentstack CLI plugin to export content from stack",
-  "version": "1.7.0",
+  "version": "1.8.1",
   "author": "Contentstack",
   "bugs": "https://github.com/contentstack/cli/issues",
   "dependencies": {
-    "@contentstack/cli-command": "^1.2.11",
-    "@contentstack/cli-utilities": "^1.5.1",
+    "@contentstack/cli-command": "~1.2.12",
+    "@contentstack/cli-utilities": "~1.5.2",
     "@oclif/command": "^1.8.16",
     "@oclif/config": "^1.18.3",
     "@oclif/core": "^2.9.3",
@@ -26,9 +26,9 @@
     "winston": "^3.7.2"
   },
   "devDependencies": {
-    "@contentstack/cli-auth": "^1.3.11",
-    "@contentstack/cli-config": "^1.4.9",
-    "@contentstack/cli-dev-dependencies": "^1.2.3",
+    "@contentstack/cli-auth": "~1.3.13",
+    "@contentstack/cli-config": "~1.4.11",
+    "@contentstack/cli-dev-dependencies": "~1.2.3",
     "@oclif/plugin-help": "^5.1.19",
     "@oclif/test": "^1.2.6",
     "@types/mkdirp": "^1.0.2",
@@ -62,6 +62,7 @@
     "lint": "eslint src/**/*.ts",
     "format": "eslint src/**/*.ts --fix",
     "test:integration": "INTEGRATION_TEST=true mocha --config ./test/.mocharc.js --forbid-only \"test/run.test.js\"",
+    "test:integration:report": "INTEGRATION_TEST=true nyc --extension .js mocha --forbid-only \"test/run.test.js\"",
     "test:unit": "mocha --forbid-only \"test/unit/*.test.ts\""
   },
   "engines": {