@zohodesk/codestandard-validator 0.0.1 → 0.0.2

package/build/utils/HuskySetup/setupHusky.js

@@ -0,0 +1,76 @@
+"use strict";
+
+/* eslint-disable no-console */
+const {
+  execSync
+} = require('child_process');
+const {
+  readdirSync
+} = require('fs');
+const path = require('path');
+const initializeHusky = require('./initializeHusky');
+const configurePrecommitHook = require('./configurePrecommitHook');
+const {
+  getNodeModulesPath
+} = require('../General/getNodeModulesPath');
+const {
+  executeSynchronizedCommands
+} = require('../General/executeSyncCommands');
+const {
+  Logger
+} = require('../Logger/Logger');
+let isCustomPrecommitConfigurationSuccessful = false;
+
+/**
+ * @function setupHusky - to setup custom precommit hook using husky plugin
+ * @returns {boolean} - indicating whether entire custom precommit hook setup using husky process is success or failure
+ */
+function setupHusky() {
+  let isHuskyPackageInstalled = installHuskyPackage();
+  if (isHuskyPackageInstalled) {
+    let isHuskyInitializedSuccessfully = initializeHusky();
+    if (isHuskyInitializedSuccessfully) {
+      Logger.log(Logger.SUCCESS_TYPE, 'Husky installation successful');
+      isCustomPrecommitConfigurationSuccessful = configurePrecommitHook();
+      if (isCustomPrecommitConfigurationSuccessful) {
+        Logger.log(Logger.SUCCESS_TYPE, 'Custom pre commit hook setup was successful');
+        return true;
+      } else {
+        Logger.log(Logger.FAILURE_TYPE, 'Couldn\'t configure custom pre commit hook');
+        return false;
+      }
+    } else {
+      return false;
+    }
+  } else {
+    Logger.log(Logger.FAILURE_TYPE, 'Some issue in installing husky package.');
+    return false;
+  }
+}
+
+/**
+ * @function installHuskyPackage - installs husky package if not installed for the project
+ * @returns {boolean} - indicating if husky package installed successfully or not
+ */
+function installHuskyPackage() {
+  const nodeModulesPathOfProject = path.join(getNodeModulesPath(), 'node_modules');
+  let pluginsInNodeModules = executeSynchronizedCommands(readdirSync, [nodeModulesPathOfProject], '', 'Unable to get directories in node_modules when checking if husky is installed', true, false);
+  let husky = {
+    packageName: 'husky',
+    version: '^7.0.4'
+  };
+  let isHuskyInstalled = pluginsInNodeModules.includes(husky.packageName) ? true : false;
+  if (!isHuskyInstalled) {
+    Logger.log(Logger.INFO_TYPE, 'Installing husky package ....');
+    let installCommand = `npm install ${husky.packageName}@${husky.version} --save-dev`;
+    let isHuskyPackageInstalled = executeSynchronizedCommands(execSync, [installCommand, {
+      stdio: 'inherit'
+    }], 'Husky package Installed Successfully', 'Unable to install husky package', false, true);
+    return isHuskyPackageInstalled;
+  }
+  Logger.log(Logger.SUCCESS_TYPE, 'Husky package already installed!');
+  return true;
+}
+module.exports = {
+  setupHusky
+};

package/build/utils/Logger/Logger.js

@@ -0,0 +1,26 @@
+"use strict";
+
+class LoggerImpl {
+  constructor() {
+    this.SUCCESS_TYPE = "success";
+    this.FAILURE_TYPE = "failure";
+    this.INFO_TYPE = "info";
+    this.colors = {
+      success: ["\x1b[36m", "\x1b[0m"],
+      failure: ["\x1b[31m", "\x1b[0m"],
+      info: ["\x1b[33m", "\x1b[0m"]
+    };
+    this.consoleLogger = console;
+  }
+  error(err) {
+    this.consoleLogger.error(err);
+  }
+  catchInfo(InfoMessage) {
+    precommit_log.set(timeStamp, InfoMessage);
+  }
+  log(type, message) {
+    const color = this.colors[type];
+    this.consoleLogger.log(`${color[0]}${message}${color[1]}`);
+  }
+}
+module.exports.Logger = new LoggerImpl();

package/build/utils/PluginsInstallation/arePluginsInstalled.js

@@ -0,0 +1,15 @@
+"use strict";
+
+const {
+  checkIfPluginsAreInstalled
+} = require('./checkIfPluginsAreInstalled');
+const {
+  printUninstalledPlugins
+} = require('./printUninstalledPlugins');
+function arePluginsInstalled() {
+  let uninstalledPlugins = checkIfPluginsAreInstalled();
+  printUninstalledPlugins(uninstalledPlugins);
+}
+module.exports = {
+  arePluginsInstalled
+};

package/build/utils/PluginsInstallation/checkIfPluginsAreInstalled.js

@@ -0,0 +1,112 @@
+"use strict";
+
+const {
+  readdirSync,
+  existsSync
+} = require('fs');
+const path = require('path');
+const {
+  getNodeModulesPath
+} = require('../General/getNodeModulesPath');
+const {
+  Logger
+} = require('../Logger/Logger');
+const {
+  getLibraryInstalledLocation
+} = require('../General/getLibraryInstalledLocation');
+const {
+  executeSynchronizedCommands
+} = require('../General/executeSyncCommands');
+const {
+  endPoint,
+  commonLinterRepoName
+} = require('../../../jsonUtils/commonLinterRepoDetails');
+const {
+  executeMethodsThatMayThrowException
+} = require('../General/wrapperFunctionToExecuteAFunction');
+const {
+  getServicePathElseCommon
+} = require('../EslintConfigFileUtils/getLintConfiguration');
+function getUnInstalledPlugins(pluginsForCurrentRepo, pluginNamesOfDevDependencyPlugins, devDependencies) {
+  let pluginsInNodeModules = executeSynchronizedCommands(readdirSync, [path.join(getNodeModulesPath(), 'node_modules')], '', 'Unable to get the plugins inside node_modules', true, false);
+  let pluginsToBeInstalled = [];
+  pluginsForCurrentRepo.filter(plugin => {
+    if (plugin.packageName.startsWith('@')) {
+      let scope = plugin.packageName.split('/')[0];
+      let pluginName = plugin.packageName.split('/')[1];
+      let scopedPlugins = executeSynchronizedCommands(readdirSync, [path.join(getNodeModulesPath(), 'node_modules', scope)], '', 'Unable to get the plugins inside the scope inside node_modules', true, false);
+      let isPluginInstalled = scopedPlugins.includes(pluginName) ? true : false;
+      if (!isPluginInstalled) {
+        pluginsToBeInstalled.push(`${plugin.packageName}@${plugin.version}`);
+      }
+    } else {
+      let isPluginInstalled = pluginsInNodeModules.includes(plugin.packageName) ? true : false;
+      if (!isPluginInstalled) {
+        pluginsToBeInstalled.push(`${plugin.packageName}@${plugin.version}`);
+      }
+    }
+    if (pluginNamesOfDevDependencyPlugins.includes(plugin.packageName)) {
+      if (plugin.version !== devDependencies[plugin.packageName]) {
+        pluginsToBeInstalled.push(`${plugin.packageName}@${plugin.version}`);
+      }
+    }
+  });
+  return pluginsToBeInstalled;
+}
+function getAllPlugins() {
+  let serviceSpecificPlugins = [];
+  const pathToCommonPluginsFile = path.join(getLibraryInstalledLocation(), commonLinterRepoName, 'common', 'pluginVersion.js');
+  let commonPlugins = executeMethodsThatMayThrowException([], 'Make sure there is a pluginVersion.js file in common folder under configuration folder', require, pathToCommonPluginsFile);
+  const {
+    pluginVersionPath: serviceSpecificPluginsFile
+  } = getServicePathElseCommon();
+  if (serviceSpecificPluginsFile !== undefined) {
+    serviceSpecificPlugins = executeMethodsThatMayThrowException([], `Kindly Ensure that Configuration is setup in Configuration repo \n ${endPoint}`, require, serviceSpecificPluginsFile);
+  } else {
+    serviceSpecificPlugins = [];
+  }
+  return [...commonPlugins, ...serviceSpecificPlugins];
+}
+
+/**
+ * @function checkIfPluginsAreInstalled - to check if all plugins present in the common linter_configuration repository has been installed or not
+ * @returns {Object} - contains two properties namely a string which says no plugins present for the repository or an empty string and an array containing plugins to be installed
+ */
+function checkIfPluginsAreInstalled() {
+  const pluginsForCurrentRepo = getAllPlugins();
+  let uninstalledPlugins = [];
+  let plugin = {
+    noPluginMessage: '',
+    uninstalledPlugins: []
+  };
+  let pluginsIndevDependencies = {};
+  let pluginNamesOfDevDependencyPlugins = [];
+  let arePluginsPresentIndevDependencies = false;
+  let arePluginsPresentForCurrentRepo = false;
+  if (existsSync(path.join(getNodeModulesPath(), 'package.json'))) {
+    let packageJsonContent = require(path.join(getNodeModulesPath(), 'package.json'));
+    pluginsIndevDependencies = packageJsonContent.devDependencies;
+    if (pluginsIndevDependencies !== undefined) {
+      arePluginsPresentIndevDependencies = true;
+      pluginNamesOfDevDependencyPlugins = Object.keys(pluginsIndevDependencies);
+    } else if (pluginsIndevDependencies === undefined) {
+      Logger.log(Logger.INFO_TYPE, 'No devDependencies present!');
+    }
+  } else {
+    arePluginsPresentIndevDependencies = false;
+  }
+  arePluginsPresentForCurrentRepo = pluginsForCurrentRepo.length !== 0 ? true : false;
+  if (arePluginsPresentForCurrentRepo || arePluginsPresentIndevDependencies) {
+    uninstalledPlugins = getUnInstalledPlugins(pluginsForCurrentRepo, pluginNamesOfDevDependencyPlugins, pluginsIndevDependencies);
+    plugin.noPluginMessage = '';
+    plugin.uninstalledPlugins = uninstalledPlugins;
+    return plugin;
+  } else {
+    plugin.noPluginMessage = 'No plugins present for the repository';
+    plugin.uninstalledPlugins = [];
+    return plugin;
+  }
+}
+module.exports = {
+  checkIfPluginsAreInstalled
+};

package/build/utils/PluginsInstallation/installPlugins.js

@@ -0,0 +1,91 @@
+"use strict";
+
+const {
+  execSync
+} = require('child_process');
+const {
+  checkIfPluginsAreInstalled
+} = require('./checkIfPluginsAreInstalled');
+const {
+  executeSynchronizedCommands
+} = require('../General/executeSyncCommands');
+const {
+  Logger
+} = require('../Logger/Logger');
+
+/**
+ * @function installPlugins - installs uninstalled plugins for the project
+ * @returns {boolean} - indicating if plugins to be installed are installed successfully or not
+ */
+function installPlugins() {
+  let uninstalledPlugins = checkIfPluginsAreInstalled();
+  let pluginsToBeInstalled = uninstalledPlugins.uninstalledPlugins;
+  if (pluginsToBeInstalled.length > 0) {
+    let installCommand = `npm install --save-dev ${pluginsToBeInstalled.join(' ')}`;
+    Logger.log(Logger.INFO_TYPE, 'Installing plugins ....');
+    Logger.log(Logger.INFO_TYPE, `Install command being executed: ${installCommand}`);
+    let arePluginsInstalledSuccessfully = executeSynchronizedCommands(execSync, [installCommand, {
+      stdio: 'inherit'
+    }], '', 'Some issue occured while installing plugins', false, true);
+    if (arePluginsInstalledSuccessfully) {
+      Logger.log(Logger.SUCCESS_TYPE, 'Plugins installation successful');
+      return true;
+    } else {
+      Logger.log(Logger.FAILURE_TYPE, "Unable to install plugins.Kindly retry the command");
+      return false;
+    }
+  } else {
+    Logger.log(Logger.INFO_TYPE, 'Plugins are already installed');
+    return true;
+  }
+}
+
+// function appendInstalledPluginsToPackageJson(pluginsToBeAppendedInPackageJson){
+//     let packageJsonFilePath = `${nodeModulesPathOfProject}/package.json`
+//     let packageJsonContent = require(packageJsonFilePath)
+//     let devDependencies = packageJsonContent.devDependencies
+//     let pluginsToBeAddedInDevDependencies = {}
+
+//     executeSynchronizedCommands(process.chdir,[nodeModulesPathOfProject],'','Unable to navigate to node_modules path when trying to revert changes in package.json',false,false)
+
+//     let gitDiffOutput = executeSynchronizedCommands(execSync,['git diff --name-only'],'','Unable to execute git diff command while checking if package.json is changed',true,false).toString().trim()
+//     let isPackageJsonChanged = gitDiffOutput.includes('package.json') ? true : false
+
+//     if(isPackageJsonChanged){
+//         let packageJsonChangesRevertCommand = `git checkout "${packageJsonFilePath}"`
+//         isPackageJsonChangesRevertedSuccessfully = executeSynchronizedCommands(execSync,[packageJsonChangesRevertCommand,{stdio:'inherit'}],'Changes in package.json reverted successfully','Unable to revert the changes in package.json file',false,true)
+
+//         if(isPackageJsonChangesRevertedSuccessfully){
+//             pluginsToBeAppendedInPackageJson.map(uninstalledPlugin => {
+//                 if(uninstalledPlugin.startsWith('@')){
+//                     let indexOfAtCharacter = uninstalledPlugin.indexOf('@')
+//                     let indexOfSecondOccurenceOfAtCharacter = uninstalledPlugin.indexOf('@',indexOfAtCharacter + 1)
+//                     let unInstalledPluginName = uninstalledPlugin.slice(0,indexOfSecondOccurenceOfAtCharacter)
+//                     let unInstalledPluginVersion = uninstalledPlugin.slice(indexOfSecondOccurenceOfAtCharacter + 1)
+//                     pluginsToBeAddedInDevDependencies[unInstalledPluginName] = unInstalledPluginVersion
+//                 }
+//                 else{
+//                     pluginsToBeAddedInDevDependencies[uninstalledPlugin.split('@')[0]] = uninstalledPlugin.split('@')[1]
+//                 }
+//                 })
+//                 let updatedPluginsIndevDependencies = {
+//                     ...devDependencies,
+//                     ...pluginsToBeAddedInDevDependencies
+//                 }
+//                 packageJsonContent.devDependencies = updatedPluginsIndevDependencies
+
+//                 let modifiedPackageJson = {
+//                     ...packageJsonContent,
+//                 }
+//                 let isPluginsAddedInPackageJson = executeSynchronizedCommands(writeFileSync,[packageJsonFilePath,JSON.stringify(modifiedPackageJson,null,2)],'Newly installed plugins successfully added to package.json','Unable to append installed plugins to package.json',false,true)
+//                 return isPluginsAddedInPackageJson 
+//         }
+//         else{
+//             return true
+//         }
+//     }
+// }
+
+module.exports = {
+  installPlugins
+};

package/build/utils/PluginsInstallation/printUninstalledPlugins.js

@@ -0,0 +1,27 @@
+"use strict";
+
+const {
+  Logger
+} = require("../Logger/Logger");
+
+/**
+ * @function printUninstalledPlugins - to notify the user regarding plugins for the repository has been installed or not 
+ * @param {Array} uninstalledPlugins - contains list of uninstalled plugins for the project
+ */
+function printUninstalledPlugins(uninstalledPlugins) {
+  let commandToInstallPlugins = 'npx ZDPrecommit setupPlugins';
+  if (uninstalledPlugins.uninstalledPlugins.length !== 0) {
+    Logger.log(Logger.INFO_TYPE, 'The following plugins are not installed:');
+    uninstalledPlugins.uninstalledPlugins.map(plugin => {
+      Logger.log(Logger.INFO_TYPE, `"${plugin}"`);
+    });
+    Logger.log(Logger.FAILURE_TYPE, `Kindly execute the command \x1b[37m"${commandToInstallPlugins}\x1b[0m" \x1b[31mfrom the location where package.json of the repo is present to install the plugins`);
+  } else if (uninstalledPlugins.uninstalledPlugins.length === 0 && uninstalledPlugins.noPluginMessage.trim() === '') {
+    Logger.log(Logger.INFO_TYPE, 'Plugins are installed already');
+  } else if (uninstalledPlugins.uninstalledPlugins.length === 0 && uninstalledPlugins.noPluginMessage.trim() !== '') {
+    Logger.log(Logger.INFO_TYPE, 'No plugins present for the repository');
+  }
+}
+module.exports = {
+  printUninstalledPlugins
+};

package/build/utils/PrecommitUsingGitSetup/update-git-precommithook.js

@@ -0,0 +1,37 @@
+"use strict";
+
+const {
+  existsSync
+} = require("fs");
+const {
+  getRootDirectory
+} = require('../General/RootDirectoryUtils/getRootDirectory');
+const {
+  getNodeModulesPath
+} = require('../General/getNodeModulesPath');
+const path = require('path');
+const fs = require('fs');
+function getCustomPrecommitHookPath() {
+  return path.resolve(getNodeModulesPath(), "node_modules", "@zohodesk", "codestandard-validator", "bin", "execute.js");
+}
+
+/**
+ * @function updateGitFile - updates default precommit hook provided by git with the custom precommit hook file
+ * @returns {null}
+ */
+function updateGitFile() {
+  const preCommit_File_Path_Default = path.resolve(getRootDirectory(), '.git', 'hooks', 'pre-commit.sample');
+  let preCommit_File_Path = path.join(path.dirname(preCommit_File_Path_Default), 'pre-commit');
+  if (existsSync(preCommit_File_Path_Default)) {
+    fs.writeFileSync(preCommit_File_Path_Default, `#!/bin/sh${getCustomPrecommitHookPath()}`);
+    fs.renameSync(preCommit_File_Path_Default, preCommit_File_Path);
+    return;
+  }
+  if (existsSync(preCommit_File_Path)) {
+    fs.appendFileSync(preCommit_File_Path, `\n${getCustomPrecommitHookPath()}`);
+    return;
+  }
+}
+module.exports = {
+  updateGitFile
+};

package/changeLog.md

@@ -4,6 +4,9 @@
  1. Testing version of the library
 
 # 0.0.1
+ - This version was mistakenly published without the build folder which will be corrected in the next release
+
+# 0.0.2 - first stable release of the library
  1. Sets up a custom precommit hook using husky
  2. clones the common linter configuration repository in developer branch 
  3. Based on the cloned configuration folder creates a eslint config file

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zohodesk/codestandard-validator",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "library to enforce code standard using eslint",
   "main": "index.js",
   "scripts": {