@contentstack/cli-cm-export 1.5.9 → 1.7.0

package/lib/utils/logger.js

@@ -0,0 +1,154 @@
+"use strict";
+/*!
+ * Contentstack Export
+ * Copyright (c) 2019 Contentstack LLC
+ * MIT Licensed
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unlinkFileLogger = exports.log = void 0;
+const tslib_1 = require("tslib");
+const winston = tslib_1.__importStar(require("winston"));
+const path = tslib_1.__importStar(require("path"));
+const mkdirp_1 = tslib_1.__importDefault(require("mkdirp"));
+const slice = Array.prototype.slice;
+const ansiRegexPattern = [
+    '[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)',
+    '(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))',
+].join('|');
+function returnString(args) {
+    let returnStr = '';
+    if (args && args.length) {
+        returnStr = args
+            .map(function (item) {
+            if (item && typeof item === 'object') {
+                try {
+                    return JSON.stringify(item).replace(/authtoken\":\d"blt................/g, 'authtoken":"blt....');
+                }
+                catch (error) { }
+                return item;
+            }
+            return item;
+        })
+            .join('  ')
+            .trim();
+    }
+    returnStr = returnStr.replace(new RegExp(ansiRegexPattern, 'g'), '').trim();
+    return returnStr;
+}
+const myCustomLevels = {
+    levels: {
+        warn: 1,
+        info: 2,
+        debug: 3,
+    },
+    colors: {
+        //colors aren't being used anywhere as of now, we're using chalk to add colors while logging
+        info: 'blue',
+        debug: 'green',
+        warn: 'yellow',
+        error: 'red',
+    },
+};
+let logger;
+let errorLogger;
+let successTransport;
+let errorTransport;
+function init(_logPath) {
+    if (!logger || !errorLogger) {
+        const logsDir = path.resolve(_logPath, 'logs', 'export');
+        // Create dir if doesn't already exist
+        mkdirp_1.default.sync(logsDir);
+        successTransport = {
+            filename: path.join(logsDir, 'success.log'),
+            maxFiles: 20,
+            maxsize: 1000000,
+            tailable: true,
+            level: 'info',
+        };
+        errorTransport = {
+            filename: path.join(logsDir, 'error.log'),
+            maxFiles: 20,
+            maxsize: 1000000,
+            tailable: true,
+            level: 'error',
+        };
+        logger = winston.createLogger({
+            transports: [
+                new winston.transports.File(successTransport),
+                new winston.transports.Console({ format: winston.format.simple() }),
+            ],
+            levels: myCustomLevels.levels,
+        });
+        errorLogger = winston.createLogger({
+            transports: [
+                new winston.transports.File(errorTransport),
+                new winston.transports.Console({
+                    level: 'error',
+                    format: winston.format.combine(winston.format.colorize({ all: true, colors: { error: 'red' } }), winston.format.simple()),
+                }),
+            ],
+            levels: { error: 0 },
+        });
+    }
+    return {
+        log: function (message) {
+            const args = slice.call(arguments);
+            const logString = returnString(args);
+            if (logString) {
+                logger.log('info', logString);
+            }
+        },
+        warn: function () {
+            const args = slice.call(arguments);
+            const logString = returnString(args);
+            if (logString) {
+                logger.log('warn', logString);
+            }
+        },
+        error: function (message) {
+            const args = slice.call(arguments);
+            const logString = returnString(args);
+            if (logString) {
+                errorLogger.log('error', logString);
+            }
+        },
+        debug: function () {
+            const args = slice.call(arguments);
+            const logString = returnString(args);
+            if (logString) {
+                logger.log('debug', logString);
+            }
+        },
+    };
+}
+const log = async (config, message, type) => {
+    config.data = config.data || path.join(__dirname, 'logs');
+    // ignoring the type argument, as we are not using it to create a logfile anymore
+    if (type !== 'error') {
+        // removed type argument from init method
+        init(config.data).log(message);
+    }
+    else {
+        init(config.data).error(message);
+    }
+};
+exports.log = log;
+const unlinkFileLogger = () => {
+    if (logger) {
+        const transports = logger.transports;
+        transports.forEach((transport) => {
+            if (transport.name === 'file') {
+                logger.remove(transport);
+            }
+        });
+    }
+    if (errorLogger) {
+        const transports = errorLogger.transports;
+        transports.forEach((transport) => {
+            if (transport.name === 'file') {
+                errorLogger.remove(transport);
+            }
+        });
+    }
+};
+exports.unlinkFileLogger = unlinkFileLogger;

package/lib/utils/marketplace-app-helper.d.ts

@@ -0,0 +1,11 @@
+import { NodeCrypto, HttpClient } from '@contentstack/cli-utilities';
+import { ExportConfig } from '../types';
+export declare const getDeveloperHubUrl: (exportConfig: ExportConfig) => Promise<any>;
+export declare function getOrgUid(config: ExportConfig): Promise<string>;
+export declare function createNodeCryptoInstance(config: ExportConfig): Promise<NodeCrypto>;
+export declare const getStackSpecificApps: (params: {
+    developerHubBaseUrl: string;
+    httpClient: HttpClient;
+    config: ExportConfig;
+    skip: number;
+}) => Promise<any>;

package/lib/utils/marketplace-app-helper.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStackSpecificApps = exports.createNodeCryptoInstance = exports.getOrgUid = exports.getDeveloperHubUrl = void 0;
+const cli_utilities_1 = require("@contentstack/cli-utilities");
+const utils_1 = require("../utils");
+const interactive_1 = require("./interactive");
+const getDeveloperHubUrl = async (exportConfig) => {
+    const { cma, name } = cli_utilities_1.configHandler.get('region') || {};
+    let developerHubBaseUrl = exportConfig === null || exportConfig === void 0 ? void 0 : exportConfig.developerHubUrls[cma];
+    if (!developerHubBaseUrl) {
+        developerHubBaseUrl = await (0, interactive_1.askDeveloperHub)(name);
+    }
+    return developerHubBaseUrl.startsWith('http') ? developerHubBaseUrl : `https://${developerHubBaseUrl}`;
+};
+exports.getDeveloperHubUrl = getDeveloperHubUrl;
+async function getOrgUid(config) {
+    const tempAPIClient = await (0, cli_utilities_1.managementSDKClient)({ host: config.host });
+    const tempStackData = await tempAPIClient
+        .stack({ api_key: config.source_stack })
+        .fetch()
+        .catch((error) => {
+        (0, utils_1.log)(this.config, (0, utils_1.formatError)(error), 'error');
+    });
+    return tempStackData === null || tempStackData === void 0 ? void 0 : tempStackData.org_uid;
+}
+exports.getOrgUid = getOrgUid;
+async function createNodeCryptoInstance(config) {
+    const cryptoArgs = { encryptionKey: '' };
+    if (config.forceStopMarketplaceAppsPrompt) {
+        cryptoArgs['encryptionKey'] = config.marketplaceAppEncryptionKey;
+    }
+    else {
+        cryptoArgs['encryptionKey'] = await cli_utilities_1.cliux.inquire({
+            type: 'input',
+            name: 'name',
+            default: config.marketplaceAppEncryptionKey,
+            validate: (url) => {
+                if (!url)
+                    return "Encryption key can't be empty.";
+                return true;
+            },
+            message: 'Enter marketplace app configurations encryption key',
+        });
+    }
+    return new cli_utilities_1.NodeCrypto(cryptoArgs);
+}
+exports.createNodeCryptoInstance = createNodeCryptoInstance;
+const getStackSpecificApps = async (params) => {
+    const { developerHubBaseUrl, httpClient, config, skip } = params;
+    return httpClient
+        .get(`${developerHubBaseUrl}/installations?target_uids=${config.source_stack}&skip=${skip}`)
+        .then((data) => data.data)
+        .catch((error) => (0, utils_1.log)(config, `Failed to export marketplace-apps ${(0, utils_1.formatError)(error)}`, 'error'));
+};
+exports.getStackSpecificApps = getStackSpecificApps;

package/lib/utils/setup-branches.d.ts

@@ -0,0 +1,3 @@
+import { ExportConfig } from '../types';
+declare const setupBranches: (config: ExportConfig, stackAPIClient: any) => Promise<void>;
+export default setupBranches;

package/lib/utils/setup-branches.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const path = tslib_1.__importStar(require("path"));
+const file_helper_1 = require("./file-helper");
+const setupBranches = async (config, stackAPIClient) => {
+    if (typeof config !== 'object') {
+        throw new Error('Invalid config to setup the branch');
+    }
+    let branches = [];
+    if (config.branchName) {
+        // check branch exists
+        const result = await stackAPIClient
+            .branch(config.branchName)
+            .fetch()
+            .catch((_err) => { });
+        if (result && typeof result === 'object') {
+            branches.push(result);
+        }
+        else {
+            throw new Error('No branch found with the given name ' + config.branchName);
+        }
+    }
+    else {
+        try {
+            const result = await stackAPIClient
+                .branch()
+                .query()
+                .find()
+                .catch((_err) => { });
+            if (result && result.items && Array.isArray(result.items) && result.items.length > 0) {
+                branches = result.items;
+            }
+            else {
+                return;
+            }
+        }
+        catch (error) {
+            // Note skips the error
+            return;
+        }
+    }
+    (0, file_helper_1.makeDirectory)(config.exportDir);
+    // create branch info file
+    (0, file_helper_1.writeFileSync)(path.join(config.exportDir, 'branches.json'), branches);
+    // add branches list in the
+    config.branches = branches;
+};
+exports.default = setupBranches;

package/lib/utils/setup-export-dir.d.ts

@@ -0,0 +1,2 @@
+import { ExportConfig } from '../types';
+export default function setupExportDir(exportConfig: ExportConfig): Promise<void[]>;

package/lib/utils/setup-export-dir.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const path_1 = tslib_1.__importDefault(require("path"));
+const file_helper_1 = require("./file-helper");
+async function setupExportDir(exportConfig) {
+    (0, file_helper_1.makeDirectory)(exportConfig.exportDir);
+    if (exportConfig.branches) {
+        return Promise.all(exportConfig.branches.map((branch) => (0, file_helper_1.makeDirectory)(path_1.default.join(exportConfig.exportDir, branch.uid))));
+    }
+}
+exports.default = setupExportDir;

package/messages/index.json

@@ -1,7 +1 @@
-{
-    "promptMessageList": {
-      "promptMasterLocale": "Provide the master locale of the source stack",
-      "promptSourceStack": "Provide the API Key of the source stack",
-      "promptPathStoredData": "Provide the path to store the content"
-    }
-}
+{}

package/oclif.manifest.json

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

package/package.json

@@ -1,33 +1,39 @@
 {
   "name": "@contentstack/cli-cm-export",
   "description": "Contentstack CLI plugin to export content from stack",
-  "version": "1.5.9",
+  "version": "1.7.0",
   "author": "Contentstack",
   "bugs": "https://github.com/contentstack/cli/issues",
   "dependencies": {
-    "@contentstack/cli-command": "^1.2.9",
-    "@contentstack/cli-utilities": "^1.4.5",
+    "@contentstack/cli-command": "^1.2.11",
+    "@contentstack/cli-utilities": "^1.5.1",
     "@oclif/command": "^1.8.16",
     "@oclif/config": "^1.18.3",
+    "@oclif/core": "^2.9.3",
     "async": "^3.2.4",
     "big-json": "^3.2.0",
     "bluebird": "^3.7.2",
     "chalk": "^4.1.2",
     "is-valid-path": "^0.1.1",
     "lodash": "^4.17.20",
-    "mkdirp": "^2.1.3",
+    "merge": "^2.1.1",
+    "mkdirp": "^1.0.4",
     "path": "^0.12.7",
     "progress-stream": "^2.0.0",
     "promise-limit": "^2.7.0",
     "proxyquire": "^2.1.3",
+    "tslib": "^2.4.1",
     "winston": "^3.7.2"
   },
   "devDependencies": {
-    "@contentstack/cli-auth": "^1.3.8",
-    "@contentstack/cli-config": "^1.4.6",
+    "@contentstack/cli-auth": "^1.3.11",
+    "@contentstack/cli-config": "^1.4.9",
     "@contentstack/cli-dev-dependencies": "^1.2.3",
     "@oclif/plugin-help": "^5.1.19",
     "@oclif/test": "^1.2.6",
+    "@types/mkdirp": "^1.0.2",
+    "@types/progress-stream": "^2.0.2",
+    "@types/mkdirp": "^1.0.2",
     "assert": "^2.0.0",
     "chai": "^4.2.0",
     "dotenv": "^16.0.1",
@@ -37,17 +43,35 @@
     "globby": "^10.0.2",
     "mocha": "10.1.0",
     "nyc": "^15.1.0",
+    "oclif": "^3.8.1",
     "sinon": "^15.0.1",
-    "oclif": "^3.8.1"
+    "ts-node": "^10.9.1",
+    "typescript": "^4.9.3"
+  },
+  "scripts": {
+    "build": "npm run clean && npm run compile",
+    "clean": "rm -rf ./lib ./node_modules tsconfig.build.tsbuildinfo",
+    "compile": "tsc -b tsconfig.json",
+    "postpack": "rm -f oclif.manifest.json",
+    "prepack": "pnpm compile && oclif manifest && oclif readme",
+    "version": "oclif readme && git add README.md",
+    "test:report": "tsc -p test && nyc --reporter=lcov --extension .ts mocha --forbid-only \"test/**/*.test.ts\"",
+    "pretest": "tsc -p test",
+    "test": "nyc --extension .ts mocha --forbid-only \"test/**/*.test.ts\"",
+    "posttest": "npm run lint",
+    "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:unit": "mocha --forbid-only \"test/unit/*.test.ts\""
   },
   "engines": {
     "node": ">=14.0.0"
   },
   "files": [
+    "/lib",
+    "/messages",
     "/npm-shrinkwrap.json",
-    "/oclif.manifest.json",
-    "/src",
-    "/messages"
+    "/oclif.manifest.json"
   ],
   "homepage": "https://github.com/contentstack/cli",
   "keywords": [
@@ -56,17 +80,9 @@
     "plugin"
   ],
   "license": "MIT",
-  "scripts": {
-    "postpack": "rm -f oclif.manifest.json",
-    "prepack": "oclif manifest && oclif readme",
-    "test": "nyc mocha --forbid-only \"test/**/*.test.js\"",
-    "version": "oclif readme && git add README.md",
-    "clean": "rm -rf ./node_modules tsconfig.build.tsbuildinfo",
-    "test:integration": "INTEGRATION_TEST=true mocha --config ./test/.mocharc.js --forbid-only \"test/run.test.js\"",
-    "test:unit": "mocha --forbid-only \"test/unit/*.test.js\" --unit-test"
-  },
+  "main": "./lib/commands/cm/stacks/export.js",
   "oclif": {
-    "commands": "./src/commands",
+    "commands": "./lib/commands",
     "bin": "csdx",
     "devPlugins": [
       "@oclif/plugin-help"
@@ -79,9 +95,8 @@
     },
     "shortCommandName": {
       "cm:stacks:export": "EXPRT",
-      "cm:export": "O-EXPRT"
+      "cm:export": "EXPRT"
     }
   },
-  "main": "./src/commands/cm/stacks/export.js",
   "repository": "https://github.com/contentstack/cli"
-}
+}

package/src/app.js

@@ -1,156 +0,0 @@
-/* eslint-disable no-redeclare */
-const _ = require('lodash');
-const path = require('path');
-const chalk = require('chalk');
-const util = require('./lib/util');
-const login = require('./lib/util/login');
-const setupBranches = require('./lib/util/setup-branches');
-const { addlogs, unlinkFileLogger } = require('./lib/util/log');
-const { managementSDKClient, isAuthenticated } = require('@contentstack/cli-utilities');
-
-exports.initial = async (config) => {
-  return new Promise(async (resolve, reject) => {
-    config = util.buildAppConfig(config);
-    util.validateConfig(config);
-    exports.getConfig = () => {
-      return config;
-    };
-
-    const APIClient = await managementSDKClient(config);
-    const stackAPIClient = APIClient.stack({
-      api_key: config.source_stack,
-      management_token: config.management_token,
-    });
-
-    const fetchBranchAndExport = async (APIClient, stackAPIClient) => {
-      await setupBranches(config, config.branchName, stackAPIClient);
-      let types = config.modules.types;
-
-      if (Array.isArray(config.branches) && config.branches.length > 0) {
-        for (let branch of config.branches) {
-          config.branchName = branch.uid;
-          try {
-            if (config.moduleName) {
-              await singleExport(APIClient, stackAPIClient, config.moduleName, types, config, branch.uid);
-            } else {
-              await allExport(APIClient, stackAPIClient, config, types, branch.uid);
-            }
-          } catch (error) {
-            addlogs(config, `failed export contents '${branch.uid}' ${util.formatError(error)}`, 'error');
-          }
-        }
-      } else {
-        try {
-          if (config.moduleName) {
-            await singleExport(APIClient, stackAPIClient, config.moduleName, types, config);
-          } else {
-            await allExport(APIClient, stackAPIClient, config, types);
-          }
-        } catch (error) {
-          addlogs(config, `failed export contents. ${util.formatError(error)}`, 'error');
-        }
-      }
-    };
-
-    if (config.management_token || config.isAuthenticated) {
-      try {
-        await fetchBranchAndExport(APIClient, stackAPIClient);
-      } catch (error) {
-        addlogs(config, `${util.formatError(error)}`, 'error');
-      }
-      resolve();
-    } else if (
-      (config.email && config.password) ||
-      (!config.email && !config.password && config.source_stack && config.access_token) ||
-      (isAuthenticated() && !config.management_token)
-    ) {
-      login
-        .login(config, APIClient, stackAPIClient)
-        .then(async function () {
-          // setup branches
-          try {
-            await fetchBranchAndExport(APIClient, stackAPIClient);
-            unlinkFileLogger();
-          } catch (error) {
-            addlogs(config, `${util.formatError(error)}`, 'error');
-          }
-          resolve();
-        })
-        .catch((error) => {
-          if (error && error.errors && error.errors.api_key) {
-            addlogs(config, `Stack Api key '${error.errors.api_key[0]}', Please enter valid Key`, 'error');
-            addlogs(config, 'The log for this is stored at ' + config.data + '/export/logs', 'success');
-          } else {
-            addlogs(config, `${util.formatError(error)}`, 'error');
-          }
-        });
-    } else {
-      reject('Kindly login or provide management_token');
-    }
-  });
-};
-
-const singleExport = async (APIClient, stackAPIClient, moduleName, types, config, branchName) => {
-  try {
-    if (types.indexOf(moduleName) > -1) {
-      let iterateList;
-      if (config.modules.dependency && config.modules.dependency[moduleName]) {
-        iterateList = config.modules.dependency[moduleName];
-      } else {
-        iterateList = ['stack'];
-      }
-      iterateList.push(moduleName);
-
-      for (let element of iterateList) {
-        const ExportModule = require('./lib/export/' + element);
-        const result = await new ExportModule(config, stackAPIClient, APIClient).start(config, branchName);
-        if (result && element === 'stack') {
-          let master_locale = {
-            master_locale: { code: result.code },
-          };
-          config = _.merge(config, master_locale);
-        }
-      }
-      addlogs(config, `Module '${moduleName}' was exported successfully!`, 'success');
-      addlogs(config, 'The log for this is stored at ' + path.join(config.data, 'logs', 'export'), 'success');
-    } else {
-      addlogs(config, 'Please provide valid module name.', 'error');
-    }
-    return true;
-  } catch (error) {
-    addlogs(config, `${util.formatError(error)}`, 'error');
-    addlogs(config, `Failed to migrate module '${moduleName}'`, 'error');
-    addlogs(config, `The log for this is stored at '${path.join(config.data, 'logs', 'export')}'`, 'error');
-  }
-};
-
-const allExport = async (APIClient, stackAPIClient, config, types, branchName) => {
-  try {
-    for (let type of types) {
-      const ExportModule = require('./lib/export/' + type);
-      const result = await new ExportModule(config, stackAPIClient, APIClient).start(config, branchName);
-
-      if (result && type === 'stack') {
-        let master_locale = { master_locale: { code: result.code } };
-        config = _.merge(config, master_locale);
-      }
-    }
-    addlogs(
-      config,
-      chalk.green(
-        'The content of stack ' + (config.sourceStackName || config.source_stack) + ' has been exported successfully!',
-      ),
-      'success',
-    );
-    addlogs(config, 'The log for this is stored at ' + path.join(config.data, 'logs', 'export'), 'success');
-    return true;
-  } catch (error) {
-    addlogs(config, util.formatError(error), 'error');
-    addlogs(
-      config,
-      `Failed to migrate stack '${config.sourceStackName || config.source_stack}'. Please check error logs for more info.`,
-      'error',
-    );
-    addlogs(config, `The log for this is stored at '${path.join(config.data, 'logs', 'export')}'`, 'error');
-  }
-};