@contentstack/cli-cm-clone 0.1.0-beta.6 → 1.1.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,36 @@
 {
   "name": "@contentstack/cli-cm-clone",
   "description": "Contentstack stack clone plugin",
-  "version": "0.1.0-beta.6",
+  "version": "1.1.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.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",
-    "@oclif/command": "^1.8.0",
-    "@oclif/config": "^1.17.0",
-    "async": "^3.2.0",
+    "@oclif/command": "^1.8.16",
+    "@oclif/config": "^1.18.3",
+    "chalk": "^4.1.0",
+    "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 +60,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,249 @@
+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,
+        'master-locale': masterLocale
+      } = 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);
+
+        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);
+        cloneHandler.execute().catch();
+      }
+
+      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) {
+      if (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) => {
+      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();
+      }
+    };
+
+    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',
+  }),
+  'master-locale': flags.string({
+    description: 'Master language for stack clone',
+  }),
+};
+
+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/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 };