@contentstack/cli-cm-clone 0.1.0-beta.6 → 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Contentstack
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -33,23 +33,23 @@ USAGE
 ```
 # Commands
 <!-- commands -->
-* [`csdx cm:stack-clone`](#csdx-cmstack-clone)
+* [`csdx cm:stacks:clone`](#csdx-cmstack-clone)
 
-## `csdx cm:stack-clone`
+## `csdx cm:stacks:clone`
 
 This command allows you to migrate data (structure or content or both) from one stack to another stack (either new or existing)
 
 ```
 USAGE
-  $ csdx cm:stack-clone
+  $ csdx cm:stacks:clone
 
 DESCRIPTION
   ...
   Use this plugin to automate the process of cloning a stack in a few steps.
 
 EXAMPLE
-  csdx cm:stack-clone
+  csdx cm:stacks:clone
 ```
 
-_See code: [src/commands/cm/stack-clone.js](https://github.com/contentstack/cli/blob/v0.1.0-beta-1/src/commands/cm/stack-clone.js)_
+_See code: [src/commands/cm/stacks/clone.js](https://github.com/contentstack/cli/blob/v0.1.0-beta-1/src/commands/cm/stack-clone.js)_
 <!-- commandsstop -->

package/package.json

@@ -1,35 +1,35 @@
 {
   "name": "@contentstack/cli-cm-clone",
   "description": "Contentstack stack clone plugin",
-  "version": "0.1.0-beta.6",
+  "version": "1.0.0",
   "author": "Contentstack",
   "bugs": "https://github.com/rohitmishra209/cli-cm-clone/issues",
   "dependencies": {
-    "@contentstack/cli-cm-export": "^0.1.1-beta.15",
-    "@contentstack/cli-cm-import": "^0.1.1-beta.18",
-    "@contentstack/cli-command": "^0.1.1-beta.6",
+    "@contentstack/cli-cm-export": "^1.0.0",
+    "@contentstack/cli-cm-import": "^1.0.0",
+    "@contentstack/cli-command": "^1.0.0",
     "@contentstack/management": "^1.3.0",
-    "@oclif/command": "^1.8.0",
-    "@oclif/config": "^1.17.0",
-    "async": "^3.2.0",
+    "@contentstack/cli-utilities": "^1.0.0",
+    "@oclif/command": "^1.8.16",
+    "@oclif/config": "^1.18.3",
+    "async": "^3.2.4",
     "child_process": "^1.0.2",
-    "configstore": "^5.0.1",
     "fancy-test": "^1.4.10",
     "inquirer": "^7.3.3",
     "ora": "^5.1.0",
     "rimraf": "^3.0.2",
-    "winston": "^3.3.3"
+    "winston": "^3.7.2"
   },
   "devDependencies": {
     "@oclif/dev-cli": "^1.22.2",
-    "@oclif/plugin-help": "^3.2.0",
+    "@oclif/plugin-help": "^5.1.12",
     "@oclif/test": "^1.2.7",
     "chai": "^4.2.0",
-    "eslint": "^5.16.0",
+    "eslint": "^8.18.0",
     "eslint-config-oclif": "^3.1.0",
     "globby": "^10.0.2",
     "jest": "^26.6.3",
-    "mocha": "^8.2.1",
+    "mocha": "^10.0.0",
     "nyc": "^14.1.1",
     "sinon": "^9.2.4"
   },
@@ -59,5 +59,10 @@
   "scripts": {
     "test": "nyc --reporter=html mocha \"test/**/*.test.js\"",
     "version": "oclif-dev readme && git add README.md"
+  },
+  "csdxConfig": {
+    "expiredCommands": {
+      "cm:stack-clone": "csdx cm:stacks:clone"
+    }
   }
 }

package/src/commands/cm/stacks/clone.js

@@ -0,0 +1,239 @@
+const { Command, flags } = require('@contentstack/cli-command');
+const { configHandler } = require('@contentstack/cli-utilities');
+const { CloneHandler } = require('../../../lib/util/clone-handler');
+let config = require('../../../lib/util/dummyConfig.json');
+const path = require('path');
+const rimraf = require('rimraf');
+let pathdir = path.join(__dirname.split('src')[0], 'contents');
+const { readdirSync } = require('fs');
+
+class StackCloneCommand extends Command {
+  async run() {
+    try {
+      let self = this;
+      let _authToken = configHandler.get('authtoken');
+      const cloneCommandFlags = self.parse(StackCloneCommand).flags;
+      const {
+        type: cloneType,
+        'stack-name': stackName,
+        'source-branch': sourceStackBranch,
+        'target-branch': targetStackBranch,
+        'source-stack-api-key': sourceStackApiKey,
+        'destination-stack-api-key': destinationStackApiKey,
+        'source-management-token-alias': sourceManagementTokenAlias,
+        'destination-management-token-alias': destinationManagementTokenAlias,
+        'import-webhook-status': importWebhookStatus,
+      } = cloneCommandFlags;
+
+      const handleClone = async () => {
+        const listOfTokens = configHandler.get('tokens');
+
+        if (cloneType) {
+          config.cloneType = cloneType;
+        }
+        if (stackName) {
+          config.stackName = stackName;
+        }
+        if (sourceStackBranch) {
+          config.sourceStackBranch = sourceStackBranch;
+        }
+        if (targetStackBranch) {
+          config.targetStackBranch = targetStackBranch;
+        }
+        if (sourceStackApiKey) {
+          config.source_stack = sourceStackApiKey;
+        }
+        if (destinationStackApiKey) {
+          config.target_stack = destinationStackApiKey;
+        }
+        if (sourceManagementTokenAlias && listOfTokens[sourceManagementTokenAlias]) {
+          config.source_alias = sourceManagementTokenAlias;
+          config.source_stack = listOfTokens[sourceManagementTokenAlias].apiKey;
+        } else if (sourceManagementTokenAlias) {
+          console.log(`Provided source token alias (${sourceManagementTokenAlias}) not found in your config.!`);
+        }
+        if (destinationManagementTokenAlias && listOfTokens[destinationManagementTokenAlias]) {
+          config.destination_alias = destinationManagementTokenAlias;
+          config.target_stack = listOfTokens[destinationManagementTokenAlias].apiKey;
+        } else if (destinationManagementTokenAlias) {
+          console.log(
+            `Provided destination token alias (${destinationManagementTokenAlias}) not found in your config.!`,
+          );
+        }
+        if (importWebhookStatus) {
+          config.importWebhookStatus = importWebhookStatus;
+        }
+
+        await this.removeContentDirIfNotEmptyBeforeClone(pathdir); // NOTE remove if folder not empty before clone
+        this.registerCleanupOnInterrupt(pathdir);
+
+        config.auth_token = _authToken;
+        config.host = this.cmaHost;
+        config.cdn = this.cdaHost;
+        const cloneHandler = new CloneHandler(config);
+        await cloneHandler.start();
+        let successMessage = 'Stack cloning process have been completed successfully';
+        await this.cleanUp(pathdir, successMessage);
+      };
+
+      if (sourceManagementTokenAlias && destinationManagementTokenAlias) {
+        if (sourceStackBranch || targetStackBranch) {
+          if (_authToken) {
+            handleClone();
+          } else {
+            console.log('Please login to execute this command, csdx auth:login');
+            this.exit(1);
+          }
+        } else {
+          handleClone();
+        }
+      } else if (_authToken) {
+        handleClone();
+      } else {
+        console.log('Please login to execute this command, csdx auth:login');
+        this.exit(1);
+      }
+    } catch (error) {
+      await this.cleanUp(pathdir);
+      // eslint-disable-next-line no-console
+      console.log(error.message || error);
+    }
+  }
+
+  async removeContentDirIfNotEmptyBeforeClone(dir) {
+    try {
+      const dirNotEmpty = readdirSync(dir).length;
+
+      if (dirNotEmpty) {
+        await this.cleanUp(dir);
+      }
+    } catch (error) {
+      const omit = ['ENOENT']; // NOTE add emittable error codes in the array
+
+      if (!omit.includes(error.code)) {
+        console.log(error.message);
+      }
+    }
+  }
+
+  cleanUp(pathDir, message) {
+    return new Promise((resolve) => {
+      rimraf(pathDir, function (err) {
+        if (err) {
+          console.log('\nCleaning up');
+          const skipCodeArr = ['ENOENT', 'EBUSY', 'EPERM', 'EMFILE', 'ENOTEMPTY'];
+
+          if (skipCodeArr.includes(err.code)) {
+            process.exit();
+          }
+        }
+
+        if (message) {
+          // eslint-disable-next-line no-console
+          console.log(message);
+        }
+
+        resolve();
+      });
+    });
+  }
+
+  registerCleanupOnInterrupt(pathDir) {
+    const interrupt = ['SIGINT', 'SIGQUIT', 'SIGTERM'];
+    const exceptions = ['unhandledRejection', 'uncaughtException'];
+
+    const cleanUp = async (exitOrError = null) => {
+      // eslint-disable-next-line no-console
+      console.log('\nCleaning up');
+      await this.cleanUp(pathDir);
+      // eslint-disable-next-line no-console
+      console.log('done');
+      // eslint-disable-next-line no-process-exit
+
+      if (exitOrError instanceof Promise) {
+        exitOrError.catch((error) => {
+          console.log((error && error.message) || '');
+        });
+      } else if (exitOrError && exitOrError.message) {
+        console.log(exitOrError.message);
+      } else if (exitOrError && exitOrError.errorMessage) {
+        console.log(exitOrError.message);
+      }
+
+      if (exitOrError === true) process.exit();
+    };
+
+    exceptions.forEach((event) => process.on(event, cleanUp));
+    interrupt.forEach((signal) => process.on(signal, () => cleanUp(true)));
+  }
+}
+
+StackCloneCommand.description = `Clone data (structure/content or both) of a stack into another stack
+Use this plugin to automate the process of cloning a stack in few steps.
+`;
+
+StackCloneCommand.examples = [
+  'csdx cm:stacks:clone',
+  'csdx cm:stacks:clone --source-branch <source-branch-name> --target-branch <target-branch-name>',
+  'csdx cm:stacks:clone --source-stack-api-key <apiKey> --destination-stack-api-key <apiKey>',
+  'csdx cm:stacks:clone --source-management-token-alias <management token alias> --destination-management-token-alias <management token alias>',
+  'csdx cm:stacks:clone --source-branch --target-branch --source-management-token-alias <management token alias> --destination-management-token-alias <management token alias>',
+  'csdx cm:stacks:clone --source-branch --target-branch --source-management-token-alias <management token alias> --destination-management-token-alias <management token alias> --type <value a or b>',
+];
+
+StackCloneCommand.aliases = ['cm:stack-clone'];
+
+StackCloneCommand.flags = {
+  'source-branch': flags.string({
+    required: false,
+    multiple: false,
+    description: 'Branch of the source stack.',
+  }),
+  'target-branch': flags.string({
+    required: false,
+    multiple: false,
+    description: 'Branch of the target stack.',
+  }),
+  'source-management-token-alias': flags.string({
+    required: false,
+    multiple: false,
+    description: 'Source API key of the target stack token alias.',
+  }),
+  'destination-management-token-alias': flags.string({
+    required: false,
+    multiple: false,
+    description: 'Source API key of the target stack token alias.',
+  }),
+  'stack-name': flags.string({
+    char: 'n',
+    required: false,
+    multiple: false,
+    description: 'Name for the new stack to store the cloned content.',
+  }),
+  type: flags.string({
+    required: false,
+    multiple: false,
+    options: ['a', 'b'],
+    description: `Type of data to clone
+a) Structure (all modules except entries & assets)
+b) Structure with content (all modules including entries & assets)
+    `,
+  }),
+  'source-stack-api-key': flags.string({
+    description: 'Source stack API Key',
+  }),
+  'destination-stack-api-key': flags.string({
+    description: 'Destination stack API Key',
+  }),
+  'import-webhook-status': flags.string({
+    description: 'Webhook state',
+    options: ['disable', 'current'],
+    required: false,
+    default: 'disable',
+  }),
+};
+
+StackCloneCommand.usage =
+  'cm:stacks:clone [--source-branch <value>] [--target-branch <value>] [--source-management-token-alias <value>] [--destination-management-token-alias <value>] [-n <value>] [--type a|b] [--source-stack-api-key <value>] [--destination-stack-api-key <value>] [--import-webhook-status disable|current]';
+
+module.exports = StackCloneCommand;

package/src/lib/util/clone-handler.js

@@ -1,255 +1,335 @@
-let inquirer = require('inquirer')
-const Configstore = require('configstore')
-const _ = require('lodash')
-const fs = require('fs')
-let ora = require('ora')
-const async = require("async");
-const path = require('path')
-
-let sdkInstance = require('../../lib/util/contentstack-management-sdk')
-let exportCmd = require('@contentstack/cli-cm-export')
-let importCmd = require('@contentstack/cli-cm-import')
-let client = {}
-let config
-
-let stackCreationConfirmation = [{
-  type: 'confirm',
-  name: 'stackCreate',
-  message: 'Want to clone content into a new stack ?',
-  initial: true
-}]
+const ora = require('ora');
+const path = require('path');
+const inquirer = require('inquirer');
+
+let sdkInstance = require('../../lib/util/contentstack-management-sdk');
+let exportCmd = require('@contentstack/cli-cm-export');
+let importCmd = require('@contentstack/cli-cm-import');
+let client = {};
+let config;
+
+let stackCreationConfirmation = [
+  {
+    type: 'confirm',
+    name: 'stackCreate',
+    message: 'Want to clone content into a new stack ?',
+    initial: true,
+  },
+];
 
 let stackName = {
   type: 'input',
   name: 'stack',
+  default: 'ABC',
   message: 'Enter name for the new stack to store the cloned content ?',
-  default: "ABC"
-}
+};
 
-let orgUidList = {}
-let stackUidList = {}
-let masterLocaleList = {}
+let orgUidList = {};
+let stackUidList = {};
+let masterLocaleList = {};
 
-let structureList = ['locales',
+let structureList = [
+  'locales',
   'environments',
   'extensions',
   'webhooks',
   'global-fields',
   'content-types',
   'workflows',
-  'labels']
-var oraMessage  
-let master_locale
+  'labels',
+];
+let master_locale;
 
 class CloneHandler {
   constructor(opt) {
-    config = opt
-    client = sdkInstance.Client(config)
+    config = opt;
+    client = sdkInstance.Client(config);
+  }
+
+  #handleOrgSelection(options = {}) {
+    return new Promise(async (resolve, reject) => {
+      const { msg = '', isSource = true } = options || {};
+      const orgList = await this.getOrganizationChoices(msg).catch(reject);
+
+      if (orgList) {
+        const orgSelected = await inquirer.prompt(orgList);
+
+        if (isSource) {
+          config.sourceOrg = orgUidList[orgSelected.Organization];
+        } else {
+          config.targetOrg = orgUidList[orgSelected.Organization];
+        }
+
+        resolve(orgSelected);
+      }
+    });
+  }
+
+  #handleStackSelection(options = {}) {
+    return new Promise(async (resolve, reject) => {
+      const { org = {}, msg = '', isSource = true } = options || {};
+      const stackList = await this.getStack(org, msg, isSource).catch(reject);
+
+      if (stackList) {
+        const selectedStack = await inquirer.prompt(stackList);
+
+        if (isSource) {
+          config.sourceStackName = selectedStack.stack;
+          master_locale = masterLocaleList[selectedStack.stack];
+          config.source_stack = stackUidList[selectedStack.stack];
+        } else {
+          config.target_stack = stackUidList[selectedStack.stack];
+          config.destinationStackName = selectedStack.stack;
+        }
+
+        resolve(selectedStack);
+      }
+    });
   }
 
-  async start() {
+  start() {
     return new Promise(async (resolve, reject) => {
-      oraMessage = "Choose an organization where your source stack exists:"
-      // export section starts from here
-      let orgdetails = this.getOrganizationChoices(oraMessage)
-      orgdetails
-      .then(async (orgList)=>{
-      var stackMessage = 'Select the source stack'  
-      var orgSelected = await inquirer.prompt(orgList)
-      let stackDetails = this.getStack(orgSelected, stackMessage)
-      stackDetails
-      .then(async (stackList)=> {
-      let stackSelected = await inquirer.prompt(stackList)
-      config.source_stack = stackUidList[stackSelected.stack]
-      master_locale = masterLocaleList[stackSelected.stack]
-      config.sourceStackName = stackSelected.stack
-      stackName.default = "Copy of " + stackSelected.stack
-        let cmdExport = this.cmdExport()
-        cmdExport.then(async () => {
-          //Import section starts from here
-                var stackCreateConfirmation = await inquirer.prompt(stackCreationConfirmation)
-                if (stackCreateConfirmation.stackCreate !== true) {
-                  oraMessage = 'Choose an organization where the destination stack exists: '
-                  let orgdetails = this.getOrganizationChoices(oraMessage)
-                  orgdetails
-                  .then(async (orgList)=>{
-                  var stackMessage = 'Choose the destination stack:'  
-                  var orgSelected = await inquirer.prompt(orgList)
-                  let stackDetails = this.getStack(orgSelected, stackMessage)
-                  stackDetails
-                  .then(async (stackList)=> {
-                  let stackSelected = await inquirer.prompt(stackList)
-                  config.target_stack = stackUidList[stackSelected.stack]
-                  config.destinationStackName = stackSelected.stack
-                  this.cloneTypeSelection()
-                    .then((msgData)=>{
-                      return resolve(msgData)
-                    }).catch((error)=>{
-                      return reject(error.errorMessage)
-                    })
-                  }).catch((error) => {
-                    return reject( error.errorMessage)
-                  })
-                }).catch((error)=>{
-                  return reject(error.errorMessage)
-                })
-              } else {
-                oraMessage = 'Choose an organization where you want to create a stack: '
-                  let orgdetails = this.getOrganizationChoices(oraMessage)
-                  orgdetails
-                  .then(async (orgList)=>{
-                  var orgSelected = await inquirer.prompt(orgList)
-                  let orgUid = orgUidList[orgSelected.Organization]
-                  this.createNewStack(orgUid)
-                  .then(()=>{
-                    this.cloneTypeSelection()
-                    .then((msgData)=>{
-                     return resolve(msgData)
-                    }).catch((error) => {
-                     return reject(error) 
-                    })
-                  }).catch((error)=>{
-                    return reject(error.errorMessage + ' Contact the Organization owner for Stack Creation access.')
-                  })
-                }).catch((error) => {
-                  return reject(error.errorMessage)
-                })
-                }
-              }).catch((error) => {
-                return reject(error)
-              })
+      let sourceStack = {};
+      const handleOrgAndStackSelection = (orgMsg, stackMsg, isSource = true) => {
+        return new Promise(async (_resolve) => {
+          const org = await this.#handleOrgSelection({ msg: orgMsg, isSource }).catch((error) =>
+            reject(error.errorMessage),
+          );
+
+          if (org) {
+            await this.#handleStackSelection({
+              org,
+              isSource,
+              msg: stackMsg,
             })
-          })
-    })
+              .then(_resolve)
+              .catch((error) => reject(error.errorMessage));
+          }
+        });
+      };
+
+      if (!config.source_stack) {
+        // NOTE Export section
+        sourceStack = await handleOrgAndStackSelection(
+          'Choose an organization where your source stack exists:',
+          'Select the source stack',
+        );
+      }
+
+      if (config.source_stack) {
+        stackName.default = config.stackName || `Copy of ${sourceStack.stack || config.source_alias}`;
+        const exportRes = await this.cmdExport().catch(reject);
+
+        if (!config.sourceStackBranch) {
+          try {
+            const branches = await client.stack({ api_key: config.source_stack }).branch().query().find();
+
+            if (branches && branches.items && branches.items.length) {
+              config.sourceStackBranch = 'main';
+            }
+          } catch (_error) {}
+        }
+
+        // NOTE Import section
+        if (exportRes) {
+          let canCreateStack = false;
+
+          if (!config.target_stack) {
+            canCreateStack = await inquirer.prompt(stackCreationConfirmation);
+          }
+
+          if (canCreateStack.stackCreate !== true) {
+            if (!config.target_stack) {
+              await handleOrgAndStackSelection(
+                'Choose an organization where the destination stack exists: ',
+                'Choose the destination stack:',
+                false,
+              );
+            }
+
+            if (config.target_stack) {
+              this.cloneTypeSelection()
+                .then(resolve)
+                .catch((error) => reject(error.errorMessage));
+            }
+          } else {
+            const destinationOrg = await this.#handleOrgSelection({
+              isSource: false,
+              msg: 'Choose an organization where you want to create a stack: ',
+            }).catch((error) => reject(error.errorMessage));
+            const orgUid = orgUidList[destinationOrg.Organization];
+            await this.createNewStack(orgUid).catch((error) => {
+              return reject(error.errorMessage + ' Contact the Organization owner for Stack Creation access.');
+            });
+
+            if (config.target_stack) {
+              this.cloneTypeSelection().then(resolve).catch(reject);
+            }
+          }
+        }
+      }
+    });
   }
 
-  getOrganizationChoices = async (oraMessage) => {
+  getOrganizationChoices = async (orgMessage) => {
     let orgChoice = {
       type: 'list',
       name: 'Organization',
-      message: oraMessage !== undefined ? oraMessage : "Choose an organization",
+      message: orgMessage !== undefined ? orgMessage : 'Choose an organization',
       choices: [],
-    }
+    };
     return new Promise(async (resolve, reject) => {
-      const spinner = ora("Fetching Organization").start()
+      const spinner = ora('Fetching Organization').start();
       try {
-        let organizations = await client.organization().fetchAll({ limit: 100 })
-        spinner.succeed("Fetched Organization")
+        let organizations = await client.organization().fetchAll({ limit: 100 });
+        spinner.succeed('Fetched Organization');
         for (let i = 0; i < organizations.items.length; i++) {
-          orgUidList[organizations.items[i].name] = organizations.items[i].uid
-          orgChoice.choices.push(organizations.items[i].name)
+          orgUidList[organizations.items[i].name] = organizations.items[i].uid;
+          orgChoice.choices.push(organizations.items[i].name);
         }
-        return resolve(orgChoice)
+        return resolve(orgChoice);
       } catch (e) {
-        spinner.fail()
-        return reject(e)
+        spinner.fail();
+        return reject(e);
       }
-    })
-  }
+    });
+  };
 
   getStack = async (answer, stkMessage) => {
     return new Promise(async (resolve, reject) => {
       let stackChoice = {
         type: 'list',
         name: 'stack',
-        message: stkMessage,
-        message: stkMessage !== undefined ? stkMessage : "Select the stack",
+        message: stkMessage !== undefined ? stkMessage : 'Select the stack',
         choices: [],
-      }
-      const spinner = ora('Fetching stacks').start()      
+      };
+      const spinner = ora('Fetching stacks').start();
       try {
-        let orgUid = orgUidList[answer.Organization]
-        let stackList = client.stack().query({ organization_uid: orgUid }).find()
+        const organization_uid = orgUidList[answer.Organization];
+        const stackList = client.stack().query({ organization_uid }).find();
         stackList
-          .then(async stacklist => {
+          .then((stacklist) => {
             for (let j = 0; j < stacklist.items.length; j++) {
-              stackUidList[stacklist.items[j].name] = stacklist.items[j].api_key
-              masterLocaleList[stacklist.items[j].name] = stacklist.items[j].master_locale
-              stackChoice.choices.push(stacklist.items[j].name)
+              stackUidList[stacklist.items[j].name] = stacklist.items[j].api_key;
+              masterLocaleList[stacklist.items[j].name] = stacklist.items[j].master_locale;
+              stackChoice.choices.push(stacklist.items[j].name);
             }
-            spinner.succeed("Fetched stack")
-            return resolve(stackChoice)
-          }).catch(error => {
-            spinner.fail()
-            return reject(error)
+            spinner.succeed('Fetched stack');
+            return resolve(stackChoice);
           })
+          .catch((error) => {
+            spinner.fail();
+            return reject(error);
+          });
       } catch (e) {
-        spinner.fail()
-        return reject(e)
+        spinner.fail();
+        return reject(e);
       }
-    })
-  }
+    });
+  };
 
   async createNewStack(orgUid) {
     return new Promise(async (resolve, reject) => {
-      let inputvalue = await inquirer.prompt(stackName)
-      let stack = { name: inputvalue.stack, master_locale: master_locale }
-      const spinner = ora('Creating New stack').start()
-      let newStack = client.stack().create({ stack }, { organization_uid: orgUid })
+      let inputvalue;
+
+      if (!config.stackName) {
+        inputvalue = await inquirer.prompt(stackName);
+      } else {
+        inputvalue = { stack: config.stackName };
+      }
+
+      let stack = { name: inputvalue.stack, master_locale: master_locale };
+      const spinner = ora('Creating New stack').start();
+      let newStack = client.stack().create({ stack }, { organization_uid: orgUid });
       newStack
-        .then(result => {
-          spinner.succeed("New Stack created Successfully name as " + result.name)
-          config.target_stack = result.api_key
-          config.destinationStackName = result.name
-          return resolve(result)
-        }).catch(error => {
-          spinner.fail()
-          return reject(error)
+        .then((result) => {
+          spinner.succeed('New Stack created Successfully name as ' + result.name);
+          config.target_stack = result.api_key;
+          config.destinationStackName = result.name;
+          return resolve(result);
         })
-    })
+        .catch((error) => {
+          spinner.fail();
+          return reject(error);
+        });
+    });
   }
 
   async cloneTypeSelection() {
     return new Promise(async (resolve, reject) => {
-      let cloneTypeSelection = [{
-        type: 'list',
-        name: 'type',
-        message: 'Choose the type of data to clone:',
-        choices: ["Structure (all modules except entries & assets)", 
-                  "Structure with content (all modules including entries & assets)"
-                ]
-      }]
-      var selectedValue = await inquirer.prompt(cloneTypeSelection)
-      let cloneType = selectedValue.type
-      config['data'] = path.join(__dirname.split("src")[0], 'contents')
-      if (cloneType === "Structure (all modules except entries & assets)") {
-        config['modules'] = structureList
-        let cmdImport = this.cmdImport()
-        cmdImport.then(() => {
-          return resolve("Stack clone Structure completed")
-        }).catch((error) => {
-          return reject(error)
-        })
+      const choices = [
+        'Structure (all modules except entries & assets)',
+        'Structure with content (all modules including entries & assets)',
+      ];
+      const cloneTypeSelection = [
+        {
+          choices,
+          type: 'list',
+          name: 'type',
+          message: 'Choose the type of data to clone:',
+        },
+      ];
+      let successMsg;
+      let selectedValue = {};
+      config['data'] = path.join(__dirname.split('src')[0], 'contents', config.sourceStackBranch || '');
+
+      if (!config.cloneType) {
+        selectedValue = await inquirer.prompt(cloneTypeSelection);
+      }
+
+      if (config.cloneType === 'a' || selectedValue.type === 'Structure (all modules except entries & assets)') {
+        config['modules'] = structureList;
+        successMsg = 'Stack clone Structure completed';
       } else {
-        let cmdImport = this.cmdImport()
-        cmdImport.then(() => {
-          return resolve("Stack clone completed with structure and content")
-        }).catch((error) => {
-          return reject(error)
-        })
+        successMsg = 'Stack clone completed with structure and content';
       }
-    })
+
+      this.cmdImport()
+        .then(() => resolve(successMsg))
+        .catch(reject);
+    });
   }
 
   async cmdExport() {
     return new Promise((resolve, reject) => {
-      let exportData = exportCmd.run(['-A', '-s', config.source_stack, '-d', __dirname.split("src")[0]+'contents'])
-      exportData.then(async () => {
-        return resolve()
-      }).catch(error => {
-        return reject(error)
-      })
-    })
+      const cmd = ['-k', config.source_stack, '-d', __dirname.split('src')[0] + 'contents'];
+
+      if (config.source_alias) {
+        cmd.push('-a', config.source_alias);
+      }
+      if (config.sourceStackBranch) {
+        cmd.push('--branch', config.sourceStackBranch);
+      }
+
+      let exportData = exportCmd.run(cmd);
+      exportData.then(() => resolve(true)).catch(reject);
+    });
   }
 
   async cmdImport() {
-    return new Promise(async (resolve, reject) => {
-       await importCmd.run(['-A', '-c', path.join(__dirname, 'dummyConfig.json')])
-       return resolve()
-    })
+    return new Promise(async (resolve, _reject) => {
+      const cmd = ['-c', path.join(__dirname, 'dummyConfig.json')];
+
+      if (config.destination_alias) {
+        cmd.push('-a', config.destination_alias);
+      }
+      if (config.sourceStackBranch) {
+        cmd.push('-d', path.join(__dirname, config.sourceStackBranch));
+      }
+      if (config.targetStackBranch) {
+        cmd.push('--branch', config.targetStackBranch);
+      }
+      if (config.importWebhookStatus) {
+        cmd.push('--import-webhook-status', config.importWebhookStatus);
+      }
+
+      await importCmd.run(cmd);
+      return resolve();
+    });
   }
 }
 
 module.exports = {
-  CloneHandler, client,
-}
+  CloneHandler,
+  client,
+};

package/src/lib/util/contentstack-management-sdk.js

@@ -1,22 +1,21 @@
-const contentstacksdk = require('@contentstack/management')
-
-
-exports.Client = function (config) {  
+const contentstacksdk = require('@contentstack/management');
 
+exports.Client = function (config) {
   const option = {
     host: config.host,
     authtoken: config.auth_token,
     maxContentLength: 100000000,
     maxBodyLength: 1000000000,
-    logHandler: (level, data) => {}
-  }
+    logHandler: (_level, _data) => {
+      // empty log handler
+    },
+  };
 
   if (config.target_stack) {
-    option.api_key = config.target_stack
+    option.api_key = config.target_stack;
   }
   if (config.source_stack) {
-    option.api_key = config.source_stack
+    option.api_key = config.source_stack;
   }
-  const client = contentstacksdk.client(option)
-  return client
-}
+  return contentstacksdk.client(option);
+};

package/src/lib/util/log.js

@@ -9,15 +9,18 @@ var path = require('path');
 var mkdirp = require('mkdirp');
 var slice = Array.prototype.slice;
 
-function returnString (args) {
+function returnString(args) {
   var returnStr = '';
   if (args && args.length) {
-    returnStr = args.map(function (item) {
-      if (item && typeof (item) === 'object') {
-        return JSON.stringify(item);
-      }
-      return item;
-    }).join('  ').trim();
+    returnStr = args
+      .map(function (item) {
+        if (item && typeof item === 'object') {
+          return JSON.stringify(item);
+        }
+        return item;
+      })
+      .join('  ')
+      .trim();
   }
   return returnStr;
 }
@@ -27,35 +30,37 @@ var myCustomLevels = {
     error: 0,
     warn: 1,
     info: 2,
-    debug: 3
+    debug: 3,
   },
   colors: {
     info: 'blue',
     debug: 'green',
     warn: 'yellow',
-    error: 'red'
-  }
+    error: 'red',
+  },
 };
 
-function init (_logPath, logfileName) {
-  var logsDir = path.resolve(_logPath, 'logs', 'import')  
+function init(_logPath, logfileName) {
+  var logsDir = path.resolve(_logPath, 'logs', 'import');
   // Create dir if doesn't already exist
-  mkdirp.sync(logsDir)
+  mkdirp.sync(logsDir);
   var logPath = path.join(logsDir, logfileName + '.log');
 
-  var transports = [new(winston.transports.File)({
-    filename: logPath,
-    maxFiles: 20,
-    maxsize: 1000000,
-    tailable: true,
-    json: true
-  })];
+  var transports = [
+    new winston.transports.File({
+      filename: logPath,
+      maxFiles: 20,
+      maxsize: 1000000,
+      tailable: true,
+      json: true,
+    }),
+  ];
 
-  transports.push(new(winston.transports.Console)());
+  transports.push(new winston.transports.Console());
 
-  var logger = new(winston.Logger)({
+  var logger = winston.createLogger({
     transports: transports,
-    levels: myCustomLevels.levels
+    levels: myCustomLevels.levels,
   });
 
   return {
@@ -86,14 +91,14 @@ function init (_logPath, logfileName) {
       if (logString) {
         logger.log('debug', logString);
       }
-    }
+    },
   };
 }
 
 exports.addlogs = async (config, message, type) => {
   if (type !== 'error') {
-    init(config.oldPath, type).log(message)
+    init(config.oldPath, type).log(message);
   } else {
-    init(config.oldPath, type).error(message)
+    init(config.oldPath, type).error(message);
   }
-}
+};

package/src/commands/cm/stack-clone.js

@@ -1,102 +0,0 @@
-const {Command} = require('@contentstack/cli-command')
-const Configstore = require('configstore')
-const credStore = new Configstore('contentstack_cli')
-const {CloneHandler} = require('../../lib/util/clone-handler')
-let config = require('../../lib/util/dummyConfig.json')
-const path = require('path')
-const rimraf = require('rimraf')
-let pathdir = path.join(__dirname.split('src')[0], 'contents')
-const { readdirSync } = require('fs')
-
-class StackCloneCommand extends Command { 
-  async run() {
-    try {
-      await this.removeContentDirIfNotEmptyBeforeClone(pathdir) // NOTE remove if folder not empty before clone
-
-      this.registerCleanupOnInterrupt(pathdir)
-      let _authToken = credStore.get('authtoken')
-      if (_authToken && _authToken !== undefined) {
-        config.auth_token = _authToken
-        config.host = this.cmaHost
-        config.cdn  = this.cdaHost
-        const cloneHandler = new CloneHandler(config)
-        await cloneHandler.start()
-        let successMessage = 'Stack cloning process have been completed successfully'
-        await this.cleanUp(pathdir, successMessage)
-      } else {
-        console.log("AuthToken is not present in local drive, Hence use 'csdx auth:login' command for login");
-      }
-    } catch (error) {
-      await this.cleanUp(pathdir)
-      // eslint-disable-next-line no-console
-      console.log(error.message || error)
-    }
-  }
-
-  async removeContentDirIfNotEmptyBeforeClone(dir) {
-    try {
-      const dirNotEmpty = readdirSync(dir).length
-
-      if (dirNotEmpty) {
-        await this.cleanUp(dir)
-      }
-    } catch (error) {
-      const omit = ['ENOENT'] // NOTE add emittable error codes in the array
-
-      if (!omit.includes(error.code)) {
-        console.log(error.message)
-      }
-    }
-  }
-
-  async cleanUp(pathDir, message) {
-    return new Promise(resolve => {
-      rimraf(pathDir, function (err) {
-        if (err)
-          throw err
-        if (message) {
-          // eslint-disable-next-line no-console
-          console.log(message)
-        }
-        resolve()
-      })
-    })
-  }
-
-  registerCleanupOnInterrupt(pathDir) {
-    const interrupt = ['SIGINT', 'SIGQUIT', 'SIGTERM']
-    const exceptions = ['unhandledRejection', 'uncaughtException']
-
-    const cleanUp = async (exitOrError = null) => {
-      // eslint-disable-next-line no-console
-      console.log('\nCleaning up')
-      await this.cleanUp(pathDir)
-      // eslint-disable-next-line no-console
-      console.log('done')
-      // eslint-disable-next-line no-process-exit
-
-      if (exitOrError instanceof Promise) {
-        exitOrError.catch(error => {
-          console.log(error && error.message || '')
-        })
-      } else if (exitOrError && exitOrError.message) {
-        console.log(exitOrError.message)
-      }
-
-      if (exitOrError === true) process.exit()
-    }
-
-    exceptions.forEach(event => process.on(event, cleanUp))
-    interrupt.forEach(signal => process.on(signal, () => cleanUp(true)))
-  }
-}
-
-StackCloneCommand.description = `Clone data (structure or content or both) of a stack into another stack
-Use this plugin to automate the process of cloning a stack in a few steps.
-`
-
-StackCloneCommand.examples = [
-  'csdx cm:stack-clone',
-]
-
-module.exports = StackCloneCommand