@zohodesk/react-cli 0.0.1-beta.17 → 0.0.1-beta.171

package/lib/utils/lint/addScripts.js

@@ -0,0 +1,27 @@
+"use strict";
+
+const fs = require('fs');
+
+const {
+  log
+} = require('..');
+
+function addScripts(scripts) {
+  fs.readFile('./package.json', 'utf8', (err, configFileString) => {
+    if (err) log('[LINT SETUP] No package.json in the current directory');else {
+      const configFile = JSON.parse(configFileString); // Still Object destructuring causes issue. 😐
+      // configFile.scripts = {
+      //   ...configFile.scripts,
+      //   ...scripts,
+      // };
+
+      configFile.scripts = Object.assign(configFile.scripts || {}, scripts);
+      const data = JSON.stringify(configFile, undefined, 2);
+      fs.writeFileSync('./package.json', data);
+    }
+  });
+}
+
+module.exports = {
+  addScripts
+};

package/lib/utils/lint/checkExistingConfig.js

@@ -0,0 +1,67 @@
+"use strict";
+
+/* eslint-disable operator-linebreak */
+
+/* eslint-disable implicit-arrow-linebreak */
+const fs = require('fs');
+
+const {
+  log
+} = require('..');
+
+const {
+  question,
+  rl
+} = require('./question');
+
+const eslintConfigFiles = ['.eslintrc.js', '.eslintrc.cjs', '.eslintrc.yaml', '.eslintrc.yml', '.eslintrc.json', '.eslintrc'];
+const prettierConfigFiles = ['.prettierrc.js', '.prettierrc.json', '.prettierrc', '.prettierrc.yml', '.prettierrc.yaml', '.prettierrc.json5', '.prettierrc.toml', '.prettierrc.cjs', '.prettier.config.js', '.prettier.config.cjs'];
+
+function isConfigExists(fileNames) {
+  return fileNames.find(file => {
+    if (fs.existsSync(file)) return true;
+    return false;
+  });
+}
+
+async function checkConflicts(files) {
+  const conflictFile = isConfigExists(files);
+
+  if (conflictFile) {
+    log(`[LINT SETUP] There's already a config exists as named ${conflictFile}`);
+    const res = await question('[LINT SETUP] Do you want to overwrite? (y/n): '); // TODO: Next cycle: Need to delete the current config file.
+    // if (res === 'y') {
+    //   exec(`rm ${conflictFile}`, (err) => {
+    //     if (err) log(err);
+    //     else {
+    //       log('Deleted ', conflictFile);
+    //     }
+    //   });
+    // }
+
+    return res;
+  }
+
+  return false;
+}
+
+async function promptForPreCommitHook() {
+  const res = await question('[LINT SETUP] Do you need a pre-commit hook for formatting and check lint errors in cached files (newly changed)? (y/n): ');
+  return res;
+}
+
+const getChoices = async () => {
+  const eslint = await checkConflicts(eslintConfigFiles);
+  const prettier = await checkConflicts(prettierConfigFiles);
+  const isESLintAllowed = eslint === false || eslint === 'y';
+  const isPrettierAllowed = prettier === false || prettier === 'y';
+  const isHookInstallEnabled = (await promptForPreCommitHook()) === 'y';
+  rl.close();
+  return [isESLintAllowed, isPrettierAllowed, isHookInstallEnabled];
+};
+
+module.exports = {
+  eslintConfigFiles,
+  prettierConfigFiles,
+  getChoices
+};

package/lib/utils/lint/copyConfigs.js

@@ -0,0 +1,24 @@
+"use strict";
+
+const fs = require('fs');
+
+const {
+  log
+} = require('..');
+
+async function copyConfigs(file) {
+  // copy the file in react-cli to current working directory
+  fs.readFile(require.resolve(`../../../files/${file}.js`), (err, data) => {
+    if (err) log("[LINT SETUP] There's error in reading the config file", file);else {
+      fs.writeFile(`.${file}.js`, data, writeError => {
+        if (writeError) {
+          log("[LINT SETUP] There's error in writing the config file: ", file, writeError);
+        } else {
+          log('[LINT SETUP] Added config file', file);
+        }
+      });
+    }
+  });
+}
+
+module.exports = copyConfigs;

package/lib/utils/lint/index.js

@@ -0,0 +1,54 @@
+"use strict";
+
+const {
+  eslintPackages,
+  prettierPackages,
+  eslintPrettierConfig,
+  runInstall,
+  installLintStaged
+} = require('./lintSetup');
+
+const {
+  log
+} = require('..');
+
+const {
+  eslintConfigFiles,
+  prettierConfigFiles,
+  getChoices
+} = require('./checkExistingConfig');
+
+const copyConfigs = require('./copyConfigs');
+
+async function main() {
+  const packages = [];
+  const [isESLintAllowed, isPrettierAllowed, isHookInstallEnabled] = await getChoices();
+
+  if (isESLintAllowed) {
+    copyConfigs('eslintrc', eslintConfigFiles);
+    packages.push(...eslintPackages);
+  }
+
+  if (isPrettierAllowed) {
+    copyConfigs('prettierrc', prettierConfigFiles);
+    packages.push(...prettierPackages);
+  }
+
+  if (isESLintAllowed && isPrettierAllowed) {
+    packages.push(...eslintPrettierConfig);
+  }
+
+  if (packages.length) {
+    const process = runInstall(packages);
+    process.on('close', () => {
+      if (isHookInstallEnabled) {
+        installLintStaged();
+      }
+    });
+  } else if (isHookInstallEnabled) {
+    installLintStaged();
+  }
+}
+
+log('[LINT SETUP] Beginning configuration...');
+main();

package/lib/utils/lint/lintScripts.js

@@ -0,0 +1,11 @@
+"use strict";
+
+const {
+  addScripts
+} = require('./addScripts');
+
+const scripts = {
+  lintSetup: 'react-cli lint-setup && npm run lintExtInstall && echo "If changes not reflected kindly restart your VSCode."',
+  lintExtInstall: 'code --install-extension dbaeumer.vscode-eslint && code --install-extension esbenp.prettier-vscode'
+};
+addScripts(scripts);

package/lib/utils/lint/lintSetup.js

@@ -0,0 +1,31 @@
+"use strict";
+
+const {
+  spawn
+} = require('child_process');
+
+const eslintPackages = ['eslint@7.18.0', 'eslint-config-airbnb@18.2.1', 'eslint-plugin-import@2.22.1', 'eslint-plugin-jsx-a11y@6.4.1', 'eslint-plugin-react@7.22.0', 'eslint-plugin-css-modules@2.11.0', '@zohodesk/eslint-plugin-react-performance@1.0.3', '@zohodesk/eslint-plugin-zsecurity@0.0.1-beta.4', 'eslint-plugin-react-hooks@4.2.0'];
+const prettierPackages = ['prettier@2.2.1'];
+const eslintPrettierConfig = ['eslint-config-prettier@7.2.0']; // const npmInstall = `npm i --save-dev ${devDependencies.join(' ')}`;
+
+function runInstall(packages) {
+  return spawn('npm', ['i', ...packages, '--save-dev'], {
+    detached: true,
+    stdio: 'inherit'
+  });
+}
+
+function installLintStaged() {
+  spawn('npx', ['mrm', 'lint-staged'], {
+    detached: true,
+    stdio: 'inherit'
+  });
+}
+
+module.exports = {
+  eslintPackages,
+  prettierPackages,
+  eslintPrettierConfig,
+  installLintStaged,
+  runInstall
+};

package/lib/utils/lint/lintStagedPreCommitHook.js

@@ -0,0 +1,7 @@
+"use strict";
+
+const {
+  installLintStaged
+} = require('./lintSetup');
+
+installLintStaged();

package/lib/utils/lint/question.js

@@ -0,0 +1,30 @@
+"use strict";
+
+/* eslint-disable no-await-in-loop */
+
+/* eslint-disable implicit-arrow-linebreak */
+const readline = require('readline');
+
+const rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout
+});
+
+const question = qn => new Promise(res => {
+  rl.question(qn, ans => res(ans));
+});
+
+async function main(qn) {
+  let answer;
+
+  while (!['n', 'y'].includes(answer)) {
+    answer = (await question(qn)).toLowerCase();
+  }
+
+  return answer;
+}
+
+module.exports = {
+  question: main,
+  rl
+};

package/lib/utils/lintReporter.js

@@ -0,0 +1,142 @@
+"use strict";
+
+let getOptions = require('./getOptions').default;
+
+let fs = require('fs');
+
+let coverageCollector = require('../jest/coverageCollector');
+
+let path = require('path');
+
+let {
+  htmlTemplate,
+  endTag
+} = require('../templates/linterConstant');
+
+let {
+  esLint: {
+    srcBranch,
+    targetBranch,
+    serviceName,
+    impactServerDomain,
+    impactRun,
+    reportType,
+    reportPath
+  }
+} = getOptions();
+
+function writeFile(filePath, data) {
+  filePath = path.join(process.cwd(), filePath); //eslint-disable-line
+
+  let dirName = path.dirname(filePath);
+
+  if (!fs.existsSync(dirName)) {
+    fs.mkdirSync(dirName);
+    fs.writeFileSync(filePath, data);
+  } else {
+    fs.writeFileSync(filePath, data);
+  }
+}
+
+let formatter = {
+  jsonFormatter: data => {
+    let finalList = [];
+    data.forEach(errorFileObj => {
+      let tempMessageList = [];
+      errorFileObj.messages.forEach(messageObj => {
+        if (messageObj.ruleId === '@zohodesk/zsecurity/no-protocol-check' || messageObj.ruleId === '@zohodesk/zsecurity/no-unsecure-html') {
+          tempMessageList.push(messageObj);
+        }
+      });
+
+      if (tempMessageList.length > 0) {
+        finalList.push(errorFileObj);
+      }
+    });
+    return finalList;
+  },
+  htmlFormatter: data => {
+    data = formatter.jsonFormatter(data); //eslint-disable-line
+
+    if (data.length > 0) {
+      let liTag = '';
+      data.forEach(errorFileObj => {
+        liTag = `${liTag}<li class="pkLi"><div class="pkRow"> <div class="pkArrowCont" onclick="toggleWrapper(this)"> <div class="pkArrow"></div></div><div class="pkFileName">File Name :</div><div class="pkUrl">${errorFileObj.filePath}</div></div><div class="pkDetails"><div class="pkDetailsHead"> <div class="pkDetailsCol">Line No</div><div class="pkDetailsCol">Type</div><div class="pkDetailsCol">Message</div><div class="pkDetailsCol">Name</div></div><div class="pkDetailsBody">`;
+        let messageTag = '';
+        errorFileObj.messages.forEach(messageObj => {
+          let errorType = messageObj.severity == 2 ? 'Error' : 'Warning'; //eslint-disable-line
+
+          messageTag = `${messageTag}<div class="pkDetailsRow"><div class="pkDetailsCol">${messageObj.line}</div><div class="pkDetailsCol pkError">${errorType}</div><div class="pkDetailsCol">${messageObj.message}</div><div class="pkDetailsCol">${messageObj.ruleId}</div></div>`;
+        });
+        liTag = `${liTag + messageTag}</div></div></li>`;
+      });
+      return `${htmlTemplate}<ul class="pkUl">${liTag}</ul>${endTag}`;
+    }
+
+    return `${htmlTemplate}<div class="pkEmpty"><div>No test results with found</div></div>${endTag}`;
+  },
+  xmlFormatter: data => {
+    data = formatter.jsonFormatter(data); //eslint-disable-line
+
+    let startTag = '<jscheck>';
+    let engTag = '</jscheck>';
+    let bodyContent = '';
+    data.forEach(errorFileObj => {
+      let startOfFile = `<file name="${errorFileObj.filePath}">`;
+      let endOfFile = '</file>';
+      let messageContent = '';
+      errorFileObj.messages.forEach(messageObj => {
+        messageContent = `${messageContent}<violation fromLine = "${messageObj.line}" type ="${messageObj.ruleId}" message ="${messageObj.message}" ></violation>`;
+      });
+      bodyContent = bodyContent + startOfFile + messageContent + endOfFile;
+    });
+    return startTag + bodyContent + engTag;
+  }
+};
+
+function formatSplitter(inputJson) {
+  let outputData;
+
+  if (reportType === 'json') {
+    outputData = JSON.stringify(formatter.jsonFormatter(inputJson));
+  } else if (reportType === 'html') {
+    outputData = formatter.htmlFormatter(inputJson);
+  } else if (reportType === 'xml') {
+    outputData = formatter.xmlFormatter(inputJson);
+  }
+
+  writeFile(reportPath, outputData);
+}
+
+module.exports = function (results) {
+  let erroredFileObjectList = [];
+  results.forEach(fileObject => {
+    if (fileObject.errorCount > 0) {
+      erroredFileObjectList.push({
+        filePath: fileObject.filePath,
+        messages: fileObject.messages,
+        errorCount: fileObject.errorCount,
+        shortPath: fileObject.filePath.split('/supportapp/')[1]
+      });
+    }
+  });
+
+  if (impactRun) {
+    coverageCollector(srcBranch, targetBranch, serviceName, impactServerDomain).then((res = {}) => {
+      let impactList = [];
+
+      if (res.STATUS) {
+        if (res.LIST.length > 0) {
+          erroredFileObjectList.forEach(errFileObj => {
+            if (res.LIST.indexOf(errFileObj.shortPath) > -1) {
+              impactList.push(errFileObj);
+            }
+          });
+          formatSplitter(impactList);
+        }
+      }
+    });
+  } else {
+    formatSplitter(erroredFileObjectList);
+  }
+};

package/lib/utils/mailSender.js

@@ -1,12 +1,10 @@
-'use strict';
+"use strict";
 
-var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();
+var _nodemailer = _interopRequireDefault(require("nodemailer"));
 
-var _nodemailer = require('nodemailer');
+var _index = require("./index");
 
-var _nodemailer2 = _interopRequireDefault(_nodemailer);
-
-var _index = require('./index');
+var _jsonHelper = require("./jsonHelper");
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
@@ -15,37 +13,30 @@ if (process.argv.length <= 6) {
   process.exit(-1);
 }
 
-var _process$argv$slice = process.argv.slice(2),
-    _process$argv$slice2 = _slicedToArray(_process$argv$slice, 6),
-    from = _process$argv$slice2[0],
-    pass = _process$argv$slice2[1],
-    to = _process$argv$slice2[2],
-    subject = _process$argv$slice2[3],
-    html = _process$argv$slice2[4],
-    cc = _process$argv$slice2[5];
-
-var transporter = _nodemailer2.default.createTransport({
-  host: 'smtp.zoho.com',
-  port: 465,
-  secure: true,
+let [from, pass, to, subject, html, cc, user, reportURL] = process.argv.slice(2);
+(0, _jsonHelper.jsonHelper)(`${process.cwd()}/result.json`, 'Report_URL', reportURL);
+
+let transporter = _nodemailer.default.createTransport({
+  host: 'smtp.tsi.zohocorpin.com',
+  port: 25,
+  secure: false,
   auth: {
-    user: from,
-    pass: pass
+    user,
+    pass
   }
 });
 
-var mailOptions = {
+let mailOptions = {
   from: from,
   to: to,
   cc: cc,
   subject: subject,
   html: html
 };
-
-transporter.sendMail(mailOptions, function (error, info) {
+transporter.sendMail(mailOptions, (error, info) => {
   if (error) {
     (0, _index.log)(error);
   } else {
-    (0, _index.log)('Email sent: ' + info.response);
+    (0, _index.log)(`Email sent: ${info.response}`);
   }
 });

package/lib/utils/pullOrigin.js

@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _child_process = require("child_process");
+
+var _utils = require("../utils");
+
+var _default = (type = 'git', branchName) => new Promise(resolve => {
+  if (type === 'git') {
+    (0, _child_process.spawnSync)('git', ['pull', 'origin', branchName], {
+      encoding: 'utf8'
+    });
+    (0, _utils.log)(branchName, 'Branch Pulled!');
+    resolve();
+  } else if (type === 'hg') {
+    (0, _child_process.spawnSync)('hg', ['pull'], {
+      encoding: 'utf8'
+    });
+    (0, _utils.log)(branchName, 'Branch Pulled!');
+    resolve();
+  }
+});
+
+exports.default = _default;

package/lib/utils/reinstallDependencies.js

@@ -0,0 +1,133 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.reinstallDependencies1 = exports.reinstallDependencies = exports.collectPackageDiff = void 0;
+
+var _fs = _interopRequireDefault(require("fs"));
+
+var _path = _interopRequireDefault(require("path"));
+
+var _child_process = require("child_process");
+
+var _gitRootDir = _interopRequireDefault(require("git-root-dir"));
+
+var _index = require("./index");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+let packageJsons = {};
+
+let packageDiffChecker = (pre, current) => {
+  let {
+    dependencies = {},
+    devDependencies = {}
+  } = current;
+  let diffs = {};
+  Object.keys(dependencies).forEach(pack => {
+    let version = dependencies[pack];
+
+    if (version !== pre.dependencies && pre.dependencies[pack]) {
+      diffs[pack] = version;
+    }
+  });
+  Object.keys(devDependencies).forEach(pack => {
+    let version = devDependencies[pack];
+
+    if (version !== pre.devDependencies && pre.devDependencies[pack]) {
+      diffs[pack] = version;
+    }
+  });
+  return diffs;
+};
+
+let collectPackageDiff = pathToSubProjects => new Promise(resolve => {
+  (0, _gitRootDir.default)(process.cwd()).then(rootDir => {
+    let projects = _fs.default.readdirSync(_path.default.join(rootDir, pathToSubProjects));
+
+    projects.forEach(project => {
+      let packageJson = _path.default.join(_path.default.join(rootDir, pathToSubProjects), project, 'package.json');
+
+      if (_fs.default.existsSync(packageJson)) {
+        packageJsons[project] = require(packageJson);
+      }
+    });
+    resolve();
+  });
+});
+
+exports.collectPackageDiff = collectPackageDiff;
+
+let reinstallDependencies1 = pathToSubProjects => {
+  (0, _gitRootDir.default)(process.cwd()).then(rootDir => {
+    let projects = _fs.default.readdirSync(_path.default.join(rootDir, pathToSubProjects));
+
+    projects.forEach(project => {
+      let prePackageJson = packageJsons[project];
+      let currentPackageJson;
+
+      if (prePackageJson) {
+        currentPackageJson = _path.default.join(_path.default.join(rootDir, pathToSubProjects), project, 'package.json');
+
+        if (_fs.default.existsSync(currentPackageJson)) {
+          currentPackageJson = require(currentPackageJson);
+        }
+      }
+
+      let projPath = _path.default.join(_path.default.join(rootDir, pathToSubProjects), project);
+
+      let diffs = packageDiffChecker(prePackageJson, currentPackageJson);
+
+      if (Object.keys(diffs).length) {
+        (0, _index.log)(diffs, `package diffs between branches for ${project} project`);
+        (0, _child_process.spawnSync)('rm', ['-rf', 'package-lock.json'], {
+          cwd: projPath,
+          stdio: 'inherit'
+        });
+        let packages = Object.keys(diffs);
+        let dummy = [];
+
+        for (let name of packages) {
+          let version = diffs[name];
+          dummy.push(`${name}@${version}`);
+        }
+
+        (0, _index.log)(`npm ${['install'].concat(dummy).join(' ')}`);
+        (0, _child_process.spawnSync)('npm', ['install'].concat(dummy), {
+          cwd: projPath,
+          stdio: 'inherit'
+        });
+      } else {
+        (0, _child_process.spawnSync)('rm', ['-rf', 'node_modules', 'package-lock.json'], {
+          cwd: projPath,
+          stdio: 'inherit'
+        });
+        (0, _child_process.spawnSync)('npm', ['install'], {
+          cwd: projPath,
+          stdio: 'inherit'
+        });
+      }
+    });
+  });
+};
+
+exports.reinstallDependencies1 = reinstallDependencies1;
+
+let reinstallDependencies = pathToSubProjects => new Promise(resolve => {
+  (0, _gitRootDir.default)(process.cwd()).then(rootDir => {
+    let projects = _fs.default.readdirSync(_path.default.join(rootDir, pathToSubProjects));
+
+    projects.forEach(project => {
+      let projPath = _path.default.join(_path.default.join(rootDir, pathToSubProjects), project);
+
+      (0, _child_process.spawnSync)('npm', ['install'], {
+        cwd: projPath,
+        stdio: 'inherit'
+      });
+      resolve();
+    });
+  });
+});
+
+exports.reinstallDependencies = reinstallDependencies;

package/lib/utils/removeAttributes.js

@@ -1,32 +1,34 @@
-'use strict';
+"use strict";
 
-var _getOptions = require('./getOptions');
-
-var _getOptions2 = _interopRequireDefault(_getOptions);
+var _getOptions = _interopRequireDefault(require("./getOptions"));
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-var options = (0, _getOptions2.default)();
+let options = (0, _getOptions.default)();
+let {
+  app: {
+    attrbuteNames
+  }
+} = options;
 
-var attrbuteNames = options.app.attrbuteNames;
+module.exports = () => ({
+  visitor: {
+    Program(path, state) {
+      let properties = state.opts.properties || [];
 
+      if (properties.length === 0) {
+        properties = properties.concat(attrbuteNames);
+      }
 
-module.exports = function () {
-  return {
-    visitor: {
-      Program: function Program(path, state) {
-        var properties = state.opts.properties || [];
-        if (properties.length === 0) {
-          properties = properties.concat(attrbuteNames);
-        }
-        path.traverse({
-          JSXIdentifier: function JSXIdentifier(path2) {
-            if (properties.indexOf(path2.node.name.toLowerCase()) > -1) {
-              path2.parentPath.remove();
-            }
+      path.traverse({
+        JSXIdentifier(path2) {
+          if (properties.indexOf(path2.node.name.toLowerCase()) > -1) {
+            path2.parentPath.remove();
           }
-        });
-      }
+        }
+
+      });
     }
-  };
-};
+
+  }
+});