@contentstack/cli-cm-clone 1.0.0 → 1.1.0

package/package.json

@@ -1,17 +1,18 @@
 {
   "name": "@contentstack/cli-cm-clone",
   "description": "Contentstack stack clone plugin",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "author": "Contentstack",
   "bugs": "https://github.com/rohitmishra209/cli-cm-clone/issues",
   "dependencies": {
-    "@contentstack/cli-cm-export": "^1.0.0",
-    "@contentstack/cli-cm-import": "^1.0.0",
-    "@contentstack/cli-command": "^1.0.0",
+    "@contentstack/cli-cm-export": "^1.1.0",
+    "@contentstack/cli-cm-import": "^1.1.0",
+    "@contentstack/cli-command": "^1.0.1",
+    "@contentstack/cli-utilities": "^1.0.2",
     "@contentstack/management": "^1.3.0",
-    "@contentstack/cli-utilities": "^1.0.0",
     "@oclif/command": "^1.8.16",
     "@oclif/config": "^1.18.3",
+    "chalk": "^4.1.0",
     "async": "^3.2.4",
     "child_process": "^1.0.2",
     "fancy-test": "^1.4.10",
@@ -65,4 +66,4 @@
       "cm:stack-clone": "csdx cm:stacks:clone"
     }
   }
-}
+}

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

@@ -23,6 +23,7 @@ class StackCloneCommand extends Command {
         'source-management-token-alias': sourceManagementTokenAlias,
         'destination-management-token-alias': destinationManagementTokenAlias,
         'import-webhook-status': importWebhookStatus,
+        'master-locale': masterLocale
       } = cloneCommandFlags;
 
       const handleClone = async () => {
@@ -67,14 +68,16 @@ class StackCloneCommand extends Command {
         await this.removeContentDirIfNotEmptyBeforeClone(pathdir); // NOTE remove if folder not empty before clone
         this.registerCleanupOnInterrupt(pathdir);
 
+        if (masterLocale) {
+          config.master_locale = { code: masterLocale }
+        }
         config.auth_token = _authToken;
         config.host = this.cmaHost;
         config.cdn = this.cdaHost;
+        config.pathDir = pathdir;
         const cloneHandler = new CloneHandler(config);
-        await cloneHandler.start();
-        let successMessage = 'Stack cloning process have been completed successfully';
-        await this.cleanUp(pathdir, successMessage);
-      };
+        cloneHandler.execute().catch();
+      }
 
       if (sourceManagementTokenAlias && destinationManagementTokenAlias) {
         if (sourceStackBranch || targetStackBranch) {
@@ -94,9 +97,11 @@ class StackCloneCommand extends Command {
         this.exit(1);
       }
     } catch (error) {
-      await this.cleanUp(pathdir);
-      // eslint-disable-next-line no-console
-      console.log(error.message || error);
+      if (error) {
+        await this.cleanUp(pathdir);
+        // eslint-disable-next-line no-console
+        console.log(error.message || error);
+      }
     }
   }
 
@@ -142,25 +147,27 @@ class StackCloneCommand extends Command {
     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);
-      }
+    const cleanUp = async (exitOrError) => {
+      if (exitOrError) {
+        // 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();
+        if (exitOrError === true) process.exit();
+      }
     };
 
     exceptions.forEach((event) => process.on(event, cleanUp));
@@ -231,6 +238,9 @@ b) Structure with content (all modules including entries & assets)
     required: false,
     default: 'disable',
   }),
+  'master-locale': flags.string({
+    description: 'Master language for stack clone',
+  }),
 };
 
 StackCloneCommand.usage =

package/src/lib/helpers/command-helpers.js

@@ -0,0 +1,67 @@
+const CloneCommand = function (execute, undo, params, parentContext) {
+  this.execute = execute.bind(parentContext);
+  this.undo = undo && undo.bind(parentContext);
+  this.params = params;
+};
+
+const HandleOrgCommand = function (params, parentContext) {
+  return new CloneCommand(parentContext.handleOrgSelection, null, params, parentContext);
+};
+
+const HandleStackCommand = function (params, parentContext) {
+  return new CloneCommand(parentContext.handleStackSelection, parentContext.execute, params, parentContext);
+};
+
+const HandleBranchCommand = function (params, parentContext) {
+  return new CloneCommand(parentContext.handleBranchSelection, parentContext.execute, params, parentContext);
+};
+
+const HandleDestinationStackCommand = function (params, parentContext) {
+  return new CloneCommand(parentContext.handleStackSelection, parentContext.executeDestination, params, parentContext);
+};
+
+const HandleExportCommand = function (params, parentContext) {
+  return new CloneCommand(parentContext.cmdExport, null, params, parentContext);
+};
+
+const SetBranchCommand = function (params, parentContext) {
+  return new CloneCommand(parentContext.setBranch, null, params, parentContext);
+};
+
+const CreateNewStackCommand = function (params, parentContext) {
+  return new CloneCommand(parentContext.createNewStack, null, params, parentContext);
+};
+
+const CloneTypeSelectionCommand = function (params, parentContext) {
+  return new CloneCommand(parentContext.cloneTypeSelection, null, params, parentContext);
+};
+
+const Clone = function () {
+  const commands = [];
+
+  return {
+    execute: async function (command) {
+      commands.push(command);
+      const result = await command.execute(command.params);
+      return result;
+    },
+    undo: async function () {
+      if (commands.length) {
+        const command = commands.pop();
+        command.undo && await command.undo(command.params);
+      }
+    },
+  };
+};
+
+module.exports = {
+  HandleOrgCommand,
+  HandleStackCommand,
+  HandleBranchCommand,
+  HandleDestinationStackCommand,
+  HandleExportCommand,
+  SetBranchCommand,
+  CreateNewStackCommand,
+  CloneTypeSelectionCommand,
+  Clone,
+};

package/src/lib/util/abort-controller.js

@@ -0,0 +1,49 @@
+'use strict';
+
+const { EventEmitter } = require('events');
+
+class CustomAbortSignal {
+  constructor() {
+    this.eventEmitter = new EventEmitter();
+    this.onabort = null;
+    this.aborted = false;
+  }
+  toString() {
+    return '[object CustomAbortSignal]';
+  }
+  get [Symbol.toStringTag]() {
+    return 'CustomAbortSignal';
+  }
+  removeEventListener(name, handler) {
+    this.eventEmitter.removeListener(name, handler);
+  }
+  addEventListener(name, handler) {
+    this.eventEmitter.on(name, handler);
+  }
+  dispatchEvent(type) {
+    const event = { type, target: this };
+    const handlerName = `on${type}`;
+
+    if (typeof this[handlerName] === 'function') this[handlerName](event);
+  }
+}
+
+class CustomAbortController {
+  constructor() {
+    this.signal = new CustomAbortSignal();
+  }
+  abort() {
+    if (this.signal.aborted) return;
+
+    this.signal.aborted = true;
+    this.signal.dispatchEvent('abort');
+  }
+  toString() {
+    return '[object CustomAbortController]';
+  }
+  get [Symbol.toStringTag]() {
+    return 'CustomAbortController';
+  }
+}
+
+module.exports = { CustomAbortController, CustomAbortSignal };

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

@@ -1,12 +1,24 @@
 const ora = require('ora');
 const path = require('path');
 const inquirer = require('inquirer');
+const rimraf = require('rimraf');
+const chalk = require('chalk');
 
-let sdkInstance = require('../../lib/util/contentstack-management-sdk');
 let exportCmd = require('@contentstack/cli-cm-export');
 let importCmd = require('@contentstack/cli-cm-import');
+const { HttpClient, chooseLocalePrompt } = require('@contentstack/cli-utilities');
+let sdkInstance = require('../../lib/util/contentstack-management-sdk');
+const defaultConfig = require('@contentstack/cli-cm-export/src/config/default');
+const { CustomAbortController } = require('./abort-controller');
+
+const {
+  HandleOrgCommand, HandleStackCommand, HandleDestinationStackCommand, HandleExportCommand,
+  SetBranchCommand, CreateNewStackCommand, CloneTypeSelectionCommand, Clone, HandleBranchCommand
+} = require('../helpers/command-helpers');
+
 let client = {};
 let config;
+let cloneCommand;
 
 let stackCreationConfirmation = [
   {
@@ -32,6 +44,7 @@ let structureList = [
   'locales',
   'environments',
   'extensions',
+  'marketplace-apps',
   'webhooks',
   'global-fields',
   'content-types',
@@ -44,9 +57,12 @@ class CloneHandler {
   constructor(opt) {
     config = opt;
     client = sdkInstance.Client(config);
+    cloneCommand = new Clone();
+    this.pathDir = opt.pathDir;
+    process.stdin.setMaxListeners(50);
   }
 
-  #handleOrgSelection(options = {}) {
+  handleOrgSelection(options = {}) {
     return new Promise(async (resolve, reject) => {
       const { msg = '', isSource = true } = options || {};
       const orgList = await this.getOrganizationChoices(msg).catch(reject);
@@ -65,113 +81,266 @@ class CloneHandler {
     });
   }
 
-  #handleStackSelection(options = {}) {
+  handleStackSelection(options = {}) {
+    let keyPressHandler;
     return new Promise(async (resolve, reject) => {
-      const { org = {}, msg = '', isSource = true } = options || {};
-      const stackList = await this.getStack(org, msg, isSource).catch(reject);
+      try {
+        const { org = {}, msg = '', isSource = true, stackAbortController } = options || {}
+
+        keyPressHandler = async function (_ch, key) {
+          if (key.name === 'backspace') {
+            stackAbortController.abort();
+            console.clear();
+            process.stdin.removeListener('keypress', keyPressHandler);
+            await cloneCommand.undo();
+          }
+        };
+        process.stdin.addListener('keypress', keyPressHandler);
 
-      if (stackList) {
-        const selectedStack = await inquirer.prompt(stackList);
+        const stackList = await this.getStack(org, msg, isSource).catch(reject)
 
-        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;
-        }
+        if (stackList) {
+          const ui = new inquirer.ui.BottomBar();
+          // Use chalk to prettify the text.
+          ui.updateBottomBar(chalk.cyan('\nFor undo operation press backspace\n'));
+
+          const selectedStack = await inquirer.prompt(stackList);
 
-        resolve(selectedStack);
+          if (stackAbortController.signal.aborted) {
+            return reject();
+          }
+          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)
+        }
+      } catch (error) {
+        return reject(error);
+      } finally {
+        if (keyPressHandler) {
+          process.stdin.removeListener('keypress', keyPressHandler);
+        }
       }
     });
   }
 
-  start() {
+  handleBranchSelection = async (options) => {
+    const { api_key, isSource = true, returnBranch = false } = options
+    const baseUrl = defaultConfig.host.startsWith('http')
+      ? defaultConfig.host
+      : `https://${defaultConfig.host}/v3`;
+
     return new Promise(async (resolve, reject) => {
-      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),
-          );
+      try {
+        const headers = { api_key }
 
-          if (org) {
-            await this.#handleStackSelection({
-              org,
-              isSource,
-              msg: stackMsg,
-            })
-              .then(_resolve)
-              .catch((error) => reject(error.errorMessage));
-          }
-        });
-      };
+        if (config.auth_token) {
+          headers['authtoken'] = config.auth_token
+        } else if (config.management_token) {
+          headers['authorization'] = config.management_token
+        }
 
-      if (!config.source_stack) {
-        // NOTE Export section
-        sourceStack = await handleOrgAndStackSelection(
-          'Choose an organization where your source stack exists:',
-          'Select the source stack',
-        );
-      }
+        // NOTE validate if source branch is exist
+        if (isSource && config.sourceStackBranch) {
+          await this.validateIfBranchExist(headers, true)
+          return resolve()
+        }
 
-      if (config.source_stack) {
-        stackName.default = config.stackName || `Copy of ${sourceStack.stack || config.source_alias}`;
-        const exportRes = await this.cmdExport().catch(reject);
+        // NOTE Validate target branch is exist
+        if (!isSource && config.targetStackBranch) {
+          await this.validateIfBranchExist(headers, false)
+          return resolve()
+        }
 
-        if (!config.sourceStackBranch) {
-          try {
-            const branches = await client.stack({ api_key: config.source_stack }).branch().query().find();
+        const spinner = ora('Fetching Branches').start();
+        const result = await new HttpClient()
+          .headers(headers)
+          .get(`${baseUrl}/stacks/branches`)
+          .then(({ data: { branches } }) => branches)
+
+        const condition = (
+          result &&
+          Array.isArray(result) &&
+          result.length > 0
+        )
+
+        // NOTE if want to get only list of branches (Pass param -> returnBranch = true )
+        if (returnBranch) {
+          resolve(condition ? result : [])
+        } else {
+          // NOTE list options to use to select branch
+          if (condition) {
+            spinner.succeed('Fetched Branches');
+            const { branch } = await inquirer.prompt({
+              type: 'list',
+              name: 'branch',
+              message: 'Choose a branch',
+              choices: result.map(row => row.uid),
+            });
 
-            if (branches && branches.items && branches.items.length) {
-              config.sourceStackBranch = 'main';
+            if (isSource) {
+              config.sourceStackBranch = branch
+            } else {
+              config.targetStackBranch = branch
             }
-          } catch (_error) {}
+          } else {
+            spinner.succeed('No branches found.!');
+          }
+
+          resolve()
         }
+      } catch (e) {
+        spinner.fail();
+        console.log(e && e.message)
+        resolve()
+      }
+    })
+  }
 
-        // NOTE Import section
-        if (exportRes) {
-          let canCreateStack = false;
+  async validateIfBranchExist(headers, isSource) {
+    const branch = isSource ? config.sourceStackBranch : config.targetStackBranch
+    const spinner = ora(`Validation if ${isSource ? 'source' : 'target'} branch exist.!`).start();
+    const isBranchExist = await HttpClient.create()
+      .headers(headers)
+      .get(`https://${config.host}/v3/stacks/branches/${branch}`)
+      .then(({ data }) => data);
+
+    const completeSpinner = (msg, method = 'succeed') => {
+      spinner[method](msg)
+      spinner.stop()
+    }
+
+    if (isBranchExist && typeof isBranchExist === 'object' && typeof isBranchExist.branch === 'object') {
+      completeSpinner(`${isSource ? 'Source' : 'Target'} branch verified.!`)
+    } else {
+      completeSpinner(`${isSource ? 'Source' : 'Target'} branch not found.!`, 'fail')
+      process.exit()
+    }
+  }
 
-          if (!config.target_stack) {
-            canCreateStack = await inquirer.prompt(stackCreationConfirmation);
-          }
+  execute() {
+    return new Promise(async (resolve, reject) => {
+      let stackAbortController;
+
+      try {
+        if (!config.source_stack) {
+          const orgMsg = 'Choose an organization where your source stack exists:';
+          const stackMsg = 'Select the source stack';
 
-          if (canCreateStack.stackCreate !== true) {
-            if (!config.target_stack) {
-              await handleOrgAndStackSelection(
-                'Choose an organization where the destination stack exists: ',
-                'Choose the destination stack:',
-                false,
+          stackAbortController = new CustomAbortController();
+
+          const org = await cloneCommand.execute(new HandleOrgCommand({ msg: orgMsg, isSource: true }, this));
+          if (org) {
+            const sourceStack = await cloneCommand.execute(new HandleStackCommand({ org, isSource: true, msg: stackMsg, stackAbortController }, this));
+
+            if (config.source_stack) {
+              if (!(config.master_locale && config.master_locale.code)) {
+
+                const res = await chooseLocalePrompt(client.stack({ api_key: config.source_stack }), 'Choose Master Locale', master_locale)
+                master_locale = res.code
+                config.master_locale = res
+              }
+              else {
+                master_locale = config.master_locale.code
+              }
+              await cloneCommand.execute(
+                new HandleBranchCommand({ api_key: config.source_stack }, this)
               );
             }
 
-            if (config.target_stack) {
-              this.cloneTypeSelection()
-                .then(resolve)
-                .catch((error) => reject(error.errorMessage));
+            if (stackAbortController.signal.aborted) {
+              return reject();
             }
+            stackName.default = config.stackName || `Copy of ${sourceStack.stack || config.source_alias}`;
           } 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.');
-            });
+            return reject('Org not found.');
+          }
+        }
+        const exportRes = await cloneCommand.execute(new HandleExportCommand(null, this));
+        await cloneCommand.execute(new SetBranchCommand(null, this));
+
+        if (exportRes) {
+          this.executeDestination().catch(() => { reject(); });
+        }
+        return resolve();
+      } catch (error) {
+        return reject(error);
+      } finally {
+        if (stackAbortController) {
+          stackAbortController.abort();
+        }
+      }
+    });
+  }
+
+  async executeDestination() {
+    return new Promise(async (resolve, reject) => {
+      let stackAbortController;
+      try {
+        stackAbortController = new CustomAbortController();
+
+        let canCreateStack = false;
+
+        if (!config.target_stack) {
+          canCreateStack = await inquirer.prompt(stackCreationConfirmation);
+        }
 
-            if (config.target_stack) {
-              this.cloneTypeSelection().then(resolve).catch(reject);
+        if (!canCreateStack.stackCreate) {
+          if (!config.target_stack) {
+            const orgMsg = 'Choose an organization where the destination stack exists: ';
+            const org = await cloneCommand.execute(new HandleOrgCommand({ msg: orgMsg }, this));
+
+            if (org) {
+              const stackMsg = 'Choose the destination stack:';
+              await cloneCommand.execute(new HandleDestinationStackCommand({ org, msg: stackMsg, stackAbortController, isSource: false }, this));
             }
           }
+
+          // NOTE GET list of branches if branches enabled
+          if (config.target_stack) {
+            await cloneCommand.execute(new HandleBranchCommand({ isSource: false, api_key: config.target_stack }, this));
+          }
+        } else {
+          const destinationOrg = await this.handleOrgSelection({ isSource: false, msg: 'Choose an organization where you want to create a stack: ' });
+          const orgUid = orgUidList[destinationOrg.Organization];
+          await cloneCommand.execute(new CreateNewStackCommand(orgUid, this));
+        }
+        await cloneCommand.execute(new CloneTypeSelectionCommand(null, this));
+        return resolve();
+      } catch (error) {
+        reject(error);
+      } finally {
+        // If not aborted and ran successfully
+        if (!stackAbortController.signal.aborted) {
+          // Call clean dir.
+          rimraf(this.pathDir, function () {
+            // eslint-disable-next-line no-console
+            console.log('Stack cloning process have been completed successfully');
+          });
         }
       }
-    });
+    })
+  }
+
+  async setBranch() {
+    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) { }
+    }
   }
 
-  getOrganizationChoices = async (orgMessage) => {
+  async getOrganizationChoices(orgMessage) {
     let orgChoice = {
       type: 'list',
       name: 'Organization',
@@ -183,9 +352,9 @@ class CloneHandler {
       try {
         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);
+        for (const element of organizations.items) {
+          orgUidList[element.name] = element.uid;
+          orgChoice.choices.push(element.name);
         }
         return resolve(orgChoice);
       } catch (e) {
@@ -195,7 +364,7 @@ class CloneHandler {
     });
   };
 
-  getStack = async (answer, stkMessage) => {
+  async getStack(answer, stkMessage) {
     return new Promise(async (resolve, reject) => {
       let stackChoice = {
         type: 'list',
@@ -209,10 +378,10 @@ class CloneHandler {
         const stackList = client.stack().query({ organization_uid }).find();
         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);
+            for (const element of stacklist.items) {
+              stackUidList[element.name] = element.api_key;
+              masterLocaleList[element.name] = element.master_locale;
+              stackChoice.choices.push(element.name);
             }
             spinner.succeed('Fetched stack');
             return resolve(stackChoice);
@@ -250,7 +419,7 @@ class CloneHandler {
         })
         .catch((error) => {
           spinner.fail();
-          return reject(error);
+          return reject(error.errorMessage + ' Contact the Organization owner for Stack Creation access.');
         });
     });
   }