@zohodesk/codestandard-validator 0.0.6-exp-18 → 0.0.6-exp-21

package/build/hooks/Precommit/pre-commit.js

@@ -1,42 +1,310 @@
 "use strict";
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = validateRemotePackages;
-var _executeSyncCommands = require("../../utils/General/executeSyncCommands");
-var _getNodeModulesPath = require("../../utils/General/getNodeModulesPath");
 const {
-  cloneViaCdt
-} = require("../../utils/CloneCommonLinterRepo/cloneViaCdt");
+  exec
+} = require('child_process');
+const fs = require('fs');
+const path = require('path');
 const {
-  createEslintConfigFile
-} = require("../../utils/EslintConfigFileUtils/createEslintConfigFile");
+  getEslintExecutablePath
+} = require('../../utils/EslintConfigFileUtils/getEslintExecutablePath');
 const {
-  getLastCommitHash,
-  getStoredCommitHash
-} = require("../../utils/General/getGeneralInfo");
+  getNodeModulesPath
+} = require('../../utils/General/getNodeModulesPath');
 const {
-  execSync
-} = require("child_process");
+  filterFiles,
+  filterWarningInFile
+} = require('../../utils/FileAndFolderOperations/filterFiles');
 const {
   Logger
-} = require("../../utils/Logger/Logger");
-async function validateRemotePackages() {
-  try {
-    if (!(getStoredCommitHash() == getLastCommitHash())) {
-      await executeMethodsThatReturnBooleanValue("Make sure zgit.csez.zohocorpin.com is accessible", cloneViaCdt, null);
-      await executeMethodsThatReturnBooleanValue("Some issue occurred in creating eslint config file.", createEslintConfigFile, null);
-      Logger.log(Logger.SUCCESS_TYPE, "Pre commit setup successfull");
+} = require('../../utils/Logger/Logger');
+const {
+  checkIfPluginsAreInstalled
+} = require('../../utils/PluginsInstallation/checkIfPluginsAreInstalled');
+const {
+  getBranchName
+} = require('../../utils/GitActions/gitActions');
+const {
+  getConfigurationPrecommit,
+  getSupportedLanguage
+} = require('../../utils/General/getGeneralInfo');
+const {
+  getRootDirectory
+} = require('../../utils/General/RootDirectoryUtils/getRootDirectory');
+const {
+  impactBasedPrecommit,
+  shouldWarningsAbortCommit
+} = getConfigurationPrecommit();
+
+/**
+ * @function isMergeCommit - This method check whether it is merge or not
+ * @returns {Boolean} -  return boolean based on latest merge changes
+ */
+async function isMergeCommit() {
+  return new Promise((resolve, reject) => {
+    exec('git rev-parse -q --verify MERGE_HEAD', (error, stderr, stdout) => {
+      if (error) {
+        reject(error.toString().trim());
+      } else if (stderr) {
+        resolve(stderr.trim());
+      } else if (stdout) {
+        resolve(stdout.trim());
+      }
+    });
+  });
+}
+
+/**
+ * @function {getStagedFiles} - methods return staged files
+ * @returns {Array<string>} -  array of  files
+ */
+
+async function getStagedFiles() {
+  return new Promise((resolve, reject) => {
+    exec("git diff --staged --name-only", (error, stderr, stdout) => {
+      if (error) {
+        if (error != null) reject("Couldn't fetch staged files");
+      } else if (stderr) {
+        resolve(filterDeltedFileFromStagedFiles(stderr.trim().split('\n')));
+      } else if (stdout.trim() === '') {
+        resolve(stdout.trim());
+      }
+    });
+  });
+}
+
+/**
+ * @function {filterDeltedFileFromStagedFiles} - filter deleted staged files
+ * @param {Array<string>} files - staged files
+ * @returns 
+ */
+function filterDeltedFileFromStagedFiles(files) {
+  return files.filter(file => {
+    const absolutePath = path.resolve(getRootDirectory(), file);
+    if (fs.existsSync(absolutePath)) {
+      return true;
     }
-    execSync("npx ZDPrecommit setupPlugins", {
-      cwd: (0, _getNodeModulesPath.getNodeModulesPath)()
+    return false;
+  });
+}
+
+/**
+ * @function findEslintErrors - method  Lint given file based on given configuration
+ * @param {*} file - path of file to lint
+ * @returns {Array<string>} -  array of command line report as a string 
+ */
+
+async function findEslintErrors(file) {
+  let nodeModulesPathOfProject = `${getNodeModulesPath()}`;
+  let eslintExecutablePath = getEslintExecutablePath();
+  let eslintConfigurationFilePath = `${nodeModulesPathOfProject}/.eslintrc.js`;
+  let isEslintExecutablePresent = fs.existsSync(eslintExecutablePath) ? true : false;
+  let isNodeModulesPresent = fs.existsSync(nodeModulesPathOfProject);
+  if (isNodeModulesPresent) {
+    if (isEslintExecutablePresent) {
+      return new Promise((resolve, reject) => {
+        exec(`npx --ignore-existing "${eslintExecutablePath}" --config "${eslintConfigurationFilePath}" --no-inline-config --resolve-plugins-relative-to="${nodeModulesPathOfProject}/node_modules" ${file}`, (error, stderr, stdout) => {
+          if (stderr) {
+            resolve(stderr.trim().split('\n'));
+          } else if (error) {
+            Logger.log(Logger.FAILURE_TYPE, error);
+            reject("Error executing eslint command");
+          } else {
+            resolve([]);
+          }
+        });
+      });
+    } else {
+      Logger.log(Logger.INFO_TYPE, 'Eslint executable not found. make sure eslint plugin is installed');
+    }
+  } else {
+    Logger.log(Logger.INFO_TYPE, 'node_modules not found');
+  }
+}
+/**
+ * @function {calculateGitDiffForFile} -  method calculate diff of file
+ * @param {*} branch_name - branch name
+ * @param {*} file - path of file
+ * @returns {Promise<Array<string>>} - array of command line report as a string 
+ */
+async function calculateGitDiffForFile(branch_name, file) {
+  let gitDiffCommand = `git diff -U0 ${branch_name.trim()} ${file}`;
+  return new Promise((resolve, reject) => {
+    exec(gitDiffCommand, (error, stderr) => {
+      if (stderr) {
+        resolve(stderr.trim().split('\n'));
+      } else if (error) {
+        reject(error);
+      }
     });
+  });
+}
+/**
+ * @function {areAllPluginsInstalled} -  method whether plugin is installed or not
+ * @returns {Boolean} - return boolean based on plugin installed or not
+ */
+
+function areAllPluginsInstalled() {
+  let unInstalledPlugins = checkIfPluginsAreInstalled().uninstalledPlugins;
+  return unInstalledPlugins.length === 0 ? true : false;
+}
+
+/**
+ * @function {isOnlyWarningsPresentInFile} - method that checks if only eslint warnings are present in a file
+ * @returns {Boolean} - returns boolean based on only warnings present or not in file
+ */
+function isOnlyWarningsPresentInFile(eslintErrorsPresent) {
+  let severityOfEachErrorInFile = [];
+  eslintErrorsPresent.map(error => {
+    let partsInString = error.split(" ");
+    let severityOfError = partsInString.find(word => word === 'error' || word === 'warning');
+    severityOfEachErrorInFile.push(severityOfError);
+  });
+  return !severityOfEachErrorInFile.includes('error');
+}
+
+/**
+ * @function {preCommitHook} - method execute pre commit hook
+ * @returns {void}
+ */
+
+async function preCommitHook() {
+  Logger.log(Logger.INFO_TYPE, 'Executing pre commit hook...');
+  Logger.log(Logger.INFO_TYPE, `working dir  : ${process.cwd()}`);
+  try {
+    let isMerge = await isMergeCommit();
+    Logger.log(Logger.INFO_TYPE, 'Looks like you have merged. So skipping pre commit check');
+    process.exit(0);
   } catch (error) {
-    Logger.log(Logger.FAILURE_TYPE, `Kindly retry npm install. & ${error.message}`);
+    if (areAllPluginsInstalled()) {
+      let staged_files = [];
+      let eslintConfigFiles = ['.eslintrc.js'];
+      let exemptionFiles = [];
+      let current_branch = '';
+      let hasEslintErrorsInChangedLines = false;
+      let hasEslintErrorsInFiles = false;
+      let areFilesStaged = false;
+      let shouldAbortCommit = false;
+      try {
+        current_branch = await getBranchName();
+      } catch {
+        Logger.log(Logger.INFO_TYPE, "Error fetching current branch");
+      }
+      try {
+        staged_files = await getStagedFiles();
+        if (!staged_files.length == 0) {
+          staged_files = filterFiles(staged_files, eslintConfigFiles, true);
+
+          // staged_files = filterFiles(staged_files,exemptionFiles) //this is the code for giving exemption to a file during pre commit
+          // if(staged_files.length === 0){
+          //     Logger.log(Logger.SUCCESS_TYPE,`Commit Successful`)
+          //     process.exit(0)
+          // }
+          areFilesStaged = true;
+          for (let file in staged_files) {
+            let currentFileName = staged_files[file];
+            let changedLinesArray = [];
+            let eslintErrorsInChangedLines = [];
+            let isOnlyEslintWarningsPresentInFile = false;
+            if (getSupportedLanguage().includes(path.extname(staged_files[file]))) {
+              try {
+                var eslintErrorsInFile = await findEslintErrors(staged_files[file]);
+                // eslintErrorsInFile = impactBasedPrecommit == false ? filterWarningInFile(eslintErrorsInFile) : eslintErrorsInFile
+                if (staged_files[file] && typeof staged_files[file] == 'string') {
+                  if (!eslintErrorsInFile.length == 0) {
+                    //Calculating changed lines in a file and storing them in respective arrays
+                    if (impactBasedPrecommit) {
+                      //git diff is computed and stored in an array
+                      let git_diff = await calculateGitDiffForFile(current_branch, staged_files[file]);
+                      changedLinesArray = git_diff.filter(line => line.startsWith('@@'));
+                      let changedLinesStartArray = [];
+                      let changedLinesEndArray = [];
+                      for (let number of changedLinesArray) {
+                        let changesStartLine = parseInt(number.split(' ')[2].split(',')[0]);
+                        changedLinesStartArray.push(changesStartLine);
+                        let changesEndLine = number.split(' ')[2].split(',')[1];
+                        if (changesEndLine === undefined) {
+                          changedLinesEndArray.push(changesStartLine);
+                        } else {
+                          changedLinesEndArray.push(changesStartLine + parseInt(changesEndLine) - 1);
+                        }
+                      }
+                      for (let error = 1; error < eslintErrorsInFile.length - 2; error++) {
+                        //eslintErrorsInFile[error].trim() - 69:26  error => Do not hardcode content. Use I18N key instead  no-hardcoding/no-hardcoding, 
+                        //eslintErrorsInFile[error].trim().split(' ')[0] => 69:26
+                        //eslintErrorsInFile[error].trim().split(' ')[0].split(':')[0] => 69
+
+                        let eslintErrorLineNumber = eslintErrorsInFile[error].trim().split(' ')[0].split(':')[0];
+                        for (let lineNumber in changedLinesStartArray) {
+                          if (eslintErrorLineNumber >= changedLinesStartArray[lineNumber] && eslintErrorLineNumber <= changedLinesEndArray[lineNumber]) {
+                            eslintErrorsInChangedLines.push(eslintErrorsInFile[error]);
+                          }
+                        }
+                      }
+                      if (eslintErrorsInChangedLines.length > 0) {
+                        isOnlyEslintWarningsPresentInFile = isOnlyWarningsPresentInFile(eslintErrorsInChangedLines);
+                        Logger.log(Logger.FAILURE_TYPE, `\x1b[1m${currentFileName}\x1b[0m`);
+                        for (let eslintError of eslintErrorsInChangedLines) {
+                          Logger.log(Logger.FAILURE_TYPE, `\x1b[37m${eslintError.trimEnd()}\x1b[0m`);
+                        }
+                        if (shouldWarningsAbortCommit) {
+                          hasEslintErrorsInChangedLines = true;
+                          shouldAbortCommit = true;
+                        } else if (!shouldWarningsAbortCommit && isOnlyEslintWarningsPresentInFile) {
+                          hasEslintErrorsInChangedLines = false;
+                        } else if (!shouldWarningsAbortCommit && !isOnlyEslintWarningsPresentInFile) {
+                          hasEslintErrorsInChangedLines = true;
+                          shouldAbortCommit = true;
+                        }
+                      }
+                    } else {
+                      if (eslintErrorsInFile.length > 0) {
+                        let startIndex = 1;
+                        let endIndex = eslintErrorsInFile.length - 2;
+                        let listOsEslintErrors = eslintErrorsInFile.slice(startIndex, endIndex);
+                        isOnlyEslintWarningsPresentInFile = isOnlyWarningsPresentInFile(listOsEslintErrors);
+                        Logger.log(Logger.FAILURE_TYPE, `\x1b[1m${currentFileName}\x1b[0m`);
+                        for (let eslintError of listOsEslintErrors) {
+                          Logger.log(Logger.FAILURE_TYPE, `\x1b[37m${eslintError.trimEnd()}\x1b[0m`);
+                        }
+                        if (shouldWarningsAbortCommit) {
+                          hasEslintErrorsInFiles = true;
+                          shouldAbortCommit = true;
+                        } else if (!shouldWarningsAbortCommit && isOnlyEslintWarningsPresentInFile) {
+                          hasEslintErrorsInFiles = false;
+                        } else if (!shouldWarningsAbortCommit && !isOnlyEslintWarningsPresentInFile) {
+                          hasEslintErrorsInFiles = true;
+                          shouldAbortCommit = true;
+                        }
+                      }
+                    }
+                  }
+                }
+              } catch (err) {
+                Logger.log(Logger.FAILURE_TYPE, err);
+                Logger.log(Logger.FAILURE_TYPE, "Error in executing eslint command");
+              }
+            }
+          }
+        } else if (staged_files.length === 0) {
+          Logger.log(Logger.INFO_TYPE, 'No files have been staged. Stage your files before committing');
+        }
+      } catch {
+        Logger.log(Logger.INFO_TYPE, 'Error executing pre commit hook');
+      }
+      if (shouldAbortCommit) {
+        Logger.log(Logger.FAILURE_TYPE, `There are eslint errors/warnings present. So commit is aborted.`);
+        process.exit(1);
+      } else if (shouldAbortCommit === false && staged_files.length !== 0) {
+        Logger.log(Logger.SUCCESS_TYPE, `Commit Successful`);
+        process.exit(0);
+      }
+    } else {
+      Logger.log(Logger.FAILURE_TYPE, 'Commit failed since some eslint plugins are not installed');
+      Logger.log(Logger.INFO_TYPE, `Kindly execute the command \x1b[37mnpx ZDPrecommit setupPlugins \x1b[33mfrom the location where package.json is present to install the plugins`);
+      Logger.log(Logger.INFO_TYPE, 'Execute the command and kindly try committing again.');
+      process.exit(1);
+    }
   }
 }
-(async function () {
-  await validateRemotePackages();
-  require('./lint');
-})();
+preCommitHook();

package/build/lib/cli.js

@@ -13,11 +13,11 @@ const {
   installEslintExtension
 } = require("../utils/ExtensionInstallation/installEslintExtension");
 const {
-  Logger
-} = require("../utils/Logger/Logger");
+  installPlugins
+} = require("../utils/PluginsInstallation/installPlugins");
 const {
-  arePluginsInstalled
-} = require("../utils/PluginsInstallation/arePluginsInstalled");
+  checkIfPluginsAreInstalled
+} = require("../utils/PluginsInstallation/checkIfPluginsAreInstalled");
 const [,, action, ...options] = process.argv;
 async function run() {
   switch (action) {
@@ -33,7 +33,10 @@ async function run() {
       }
     case "setupPlugins":
       {
-        arePluginsInstalled();
+        const {
+          uninstalledPlugins
+        } = checkIfPluginsAreInstalled();
+        await executeMethodsThatReturnBooleanValue("Some issue occurred in installing plugins", installPlugins, uninstalledPlugins);
         break;
       }
     case "setupExtension":
@@ -43,7 +46,6 @@ async function run() {
       }
     default:
       {
-        Logger.log(Logger.FAILURE_TYPE, `oops! command not supported :( ...`);
         break;
       }
   }

package/build/lib/postinstall.js

@@ -36,7 +36,7 @@ async function postInstall() {
     await executeMethodsThatReturnBooleanValue("Make sure zgit.csez.zohocorpin.com is accessible", cloneViaCdt, null);
     await executeMethodsThatReturnBooleanValue("Some issue occurred in creating eslint config file.", createEslintConfigFile, null);
     Logger.log(Logger.SUCCESS_TYPE, "Pre commit setup successfull");
-    // arePluginsInstalled();
+    arePluginsInstalled();
   } catch (error) {
     Logger.log(Logger.FAILURE_TYPE, `Kindly retry npm install. & ${error.message}`);
   }

package/build/utils/CloneCommonLinterRepo/cloneViaCdt.js

@@ -49,9 +49,9 @@ function cloneViaCdt() {
   const runningEnv = getRunningEnv();
   if (runningEnv === "CI" || runningEnv === "DEVAUTOMATION") {
     Logger.log(Logger.INFO_TYPE, `Running in ${runningEnv}`);
-    absoluteEndPoint = `https://${userName}:${decrypt(token, 12)}@${endPoint}`;
+    absoluteEndPoint = `https://${userName}:${decrypt(token, process.env.DECRYPT_TOKEN)}@${endPoint}`;
   }
-  var commandToCloneCommonConfigRepo = `npx cdt clone --clone:type=${type} --clone:url=${absoluteEndPoint} --clone:branch=${branch} --clone:cacheDir=${cacheDirectory} --clone:proj:name=${commonLinterRepoName}`;
+  var commandToCloneCommonConfigRepo = `npx cdt clone --clone:type=${type} --clone:url=${absoluteEndPoint} --clone:branch=${process.env.CONFIGURATION_BRANCH || branch} --clone:cacheDir=${cacheDirectory} --clone:proj:name=${commonLinterRepoName}`;
   let isCommonConfigurationClonedSuccessfully = executeSynchronizedCommands(execSync, [commandToCloneCommonConfigRepo, {
     cwd: getClonedDirPath()
   }], `Lint Configuration Cloned Successfully - ${getRepoName() || 'common'}`, 'Could not clone the linters common repo', false, true);

package/build/utils/ConfigFileUtils/createConfigFiles.js

@@ -0,0 +1,68 @@
+"use strict";
+
+const path = require('path');
+const {
+  writeFileSync,
+  existsSync,
+  unlinkSync,
+  readFileSync
+} = require('fs');
+const {
+  getNodeModulesPath
+} = require('../General/getNodeModulesPath.js');
+const {
+  Logger
+} = require('../Logger/Logger.js');
+const {
+  executeSynchronizedCommands
+} = require('../General/executeSyncCommands.js');
+const {
+  getServicePathElseCommon
+} = require('./getLintConfiguration.js');
+
+/**
+ * Creates the ESLint configuration file from the service-specific or common template.
+ * Also creates the Stylelint configuration file if available.
+ *
+ * @returns {boolean} Success status of ESLint config creation
+ */
+function createConfigFiles() {
+  const eslintConfigFilePath = path.join(getNodeModulesPath(), '.eslintrc.js');
+  const stylelintConfigFilePath = path.join(getNodeModulesPath(), '.stylelintrc.js');
+  const {
+    pathOfServiceSpecificEslintConfigFile,
+    cssLintConfig
+  } = getServicePathElseCommon();
+  try {
+    const eslintContent = readConfig(pathOfServiceSpecificEslintConfigFile, 'eslint');
+    const stylelintContent = readConfig(cssLintConfig, 'stylelint');
+    if (stylelintContent) {
+      writeConfig(stylelintConfigFilePath, stylelintContent, 'stylelint');
+    }
+    if (existsSync(eslintConfigFilePath)) {
+      executeSynchronizedCommands(unlinkSync, [eslintConfigFilePath], 'ESLint configuration file removed successfully!', 'Unable to remove the ESLint config file.', false, false);
+    }
+    return writeConfig(eslintConfigFilePath, eslintContent, 'eslint');
+  } catch (error) {
+    Logger.log(Logger.FAILURE_TYPE, error);
+    Logger.log(Logger.FAILURE_TYPE, 'Error occurred while creating ESLint config file');
+    return false;
+  }
+}
+
+/**
+ * Reads a configuration file with logging and error handling.
+ */
+function readConfig(filePath, type) {
+  return executeSynchronizedCommands(readFileSync, [filePath, 'utf-8'], '', `Unable to read content of ${type} config file.`, true, false);
+}
+
+/**
+ * Writes a configuration file with logging and error handling.
+ */
+function writeConfig(filePath, content, type) {
+  return executeSynchronizedCommands(writeFileSync, [filePath, content, 'utf-8'], `${type[0].toUpperCase() + type.slice(1)} configuration file created successfully!`, `Unable to create and write a ${type} configuration file.`, false, true);
+}
+module.exports = {
+  createConfigFiles
+};

package/build/utils/ConfigFileUtils/getEslintExecutablePath.js

@@ -0,0 +1,24 @@
+"use strict";
+
+const path = require('path');
+const {
+  readdirSync
+} = require('fs');
+const {
+  getNodeModulesPath
+} = require('../General/getNodeModulesPath');
+const {
+  executeSynchronizedCommands
+} = require('../General/executeSyncCommands');
+const {
+  getLibraryInstalledLocation
+} = require('../General/getLibraryInstalledLocation');
+function getEslintExecutablePath() {
+  let eslintLibraryName = 'eslint';
+  let librariesInNodeModulesOfProject = executeSynchronizedCommands(readdirSync, [path.join(getNodeModulesPath(), 'node_modules')], '', 'Unable to get the plugins inside node_modules', true, false);
+  let isEslintInstalledinProject = librariesInNodeModulesOfProject.some(library => library === eslintLibraryName);
+  return isEslintInstalledinProject ? path.join(getNodeModulesPath(), 'node_modules', eslintLibraryName, 'bin', 'eslint.js') : path.join(getLibraryInstalledLocation(), 'node_modules', eslintLibraryName, 'bin', 'eslint.js');
+}
+module.exports = {
+  getEslintExecutablePath
+};

package/build/utils/ConfigFileUtils/getLintConfiguration.js

@@ -0,0 +1,54 @@
+"use strict";
+
+const path = require('path');
+const {
+  existsSync
+} = require('fs');
+const {
+  endPoint,
+  commonLinterRepoName
+} = require("../../../jsonUtils/commonLinterRepoDetails.js");
+const {
+  getRepoName
+} = require('../GitActions/gitActions.js');
+const {
+  getLibraryInstalledLocation
+} = require('../General/getLibraryInstalledLocation.js');
+const {
+  executeMethodsThatMayThrowException
+} = require("../General/wrapperFunctionToExecuteAFunction.js");
+
+/**
+ * @function getLintConfiguration - returns eslint configuration file from common linters repo
+ * @returns {object} - containing properties of the eslint configuration file
+ */
+function getServicePathElseCommon() {
+  const repoName = getRepoName();
+  const libraryInstalledLocation = getLibraryInstalledLocation();
+  let commonConfigPath = path.join(libraryInstalledLocation, commonLinterRepoName, 'common', 'index.js');
+  const _configurationPath = repoName && existsSync(path.join(libraryInstalledLocation, commonLinterRepoName, 'services', repoName, 'index.js')) ? path.join(libraryInstalledLocation, commonLinterRepoName, 'services', repoName, 'index.js') : commonConfigPath;
+  let _pathOfServiceSpecificEslintConfigFile = repoName && existsSync(path.join(libraryInstalledLocation, commonLinterRepoName, 'services', repoName, '.eslintrc.js')) ? path.join(libraryInstalledLocation, commonLinterRepoName, 'services', repoName, '.eslintrc.js') : path.join(libraryInstalledLocation, commonLinterRepoName, 'common', '.eslintrc.js');
+  let _pluginVersionPath = repoName && existsSync(path.join(libraryInstalledLocation, commonLinterRepoName, 'services', repoName, 'pluginVersion.js')) ? path.join(libraryInstalledLocation, commonLinterRepoName, 'services', repoName, 'pluginVersion.js') : undefined;
+  let _stylelintPath = repoName && existsSync(path.join(libraryInstalledLocation, commonLinterRepoName, 'services', repoName, '.stylelintrc.js')) ? path.join(libraryInstalledLocation, commonLinterRepoName, 'services', repoName, '.stylelintrc.js') : path.join(libraryInstalledLocation, commonLinterRepoName, 'common', '.stylelintrc.js');
+  return {
+    configurationPath: _configurationPath,
+    pathOfServiceSpecificEslintConfigFile: _pathOfServiceSpecificEslintConfigFile,
+    pluginVersionPath: _pluginVersionPath,
+    cssLintConfig: _stylelintPath
+  };
+}
+function getLintConfigurationUtil() {
+  const {
+    configurationPath
+  } = getServicePathElseCommon();
+  const exceptionHandleObject = {
+    rulesConfig: [{}, {}],
+    plugins: [],
+    extendPlugins: []
+  };
+  return executeMethodsThatMayThrowException(exceptionHandleObject, `Kindly Ensure that Configuration is setup in Configuration repo \n ${endPoint}`, require, configurationPath);
+}
+module.exports = {
+  getLintConfigurationUtil,
+  getServicePathElseCommon
+};

package/build/utils/FileAndFolderOperations/versionControl.js

@@ -16,13 +16,14 @@ const {
 function createVersionControlFile(uninstalledPlugins) {
   Logger.log(Logger.INFO_TYPE, `Rule Plugin Versions are Noted in pluginVersionControl.js`);
   const versionfilePath = path.join(getNodeModulesPath(), 'node_modules', '@zohodesk', 'codestandard-validator', 'pluginVersionControl.js');
-  existsSync(versionfilePath) && writeFileSync(versionfilePath, '');
-  writeFileSync(versionfilePath, `module.exports.plugins = [${uninstalledPlugins.map(plugin => {
-    return JSON.stringify({
-      plugin: `${plugin}`,
-      time: `${new Date()}`
-    });
-  }).join(',')}]`);
+  if (existsSync(versionfilePath)) {
+    writeFileSync(versionfilePath, `module.exports.plugins = [${uninstalledPlugins.map(plugin => {
+      return JSON.stringify({
+        plugin: `${plugin}`,
+        time: `${new Date()}`
+      });
+    }).join(',')}]`);
+  }
 }
 module.exports = {
   createVersionControlFile

package/build/utils/General/getGeneralInfo.js

@@ -6,13 +6,6 @@ const fs = require("fs");
 const {
   execSync
 } = require('child_process');
-const {
-  Logger
-} = require('../Logger/Logger');
-const {
-  readOnlyToken,
-  commitHashEndPoint
-} = require('../../../jsonUtils/commonLinterRepoDetails');
 
 /**
  * @function getTimeStampInfo - to fetch various timestamp details
@@ -67,63 +60,16 @@ function getSupportedLanguage() {
   const _language = supportedExtensions;
   return _language;
 }
-
-/**
- * @function getRunningEnv - Retrieves the current running environment by executing the `npm config get lint_env` command.
- * @returns {string} The current lint environment value set in the npm config.
- */
-
 function getRunningEnv() {
   const command = "npm config get lint_env";
   return execSync(command, {
     shell: true
   }).toString().trim();
 }
-
-/**
- * @function getLastCommitHash - Fetches the last commit hash from a GitLab project using its API.
- * 
- * @note This function assumes access to a specific GitLab instance and a hardcoded token and project ID.
- * @returns {string} The latest commit hash (SHA) from the specified GitLab repository.
- * @throws {Error} Will throw an error if the API request fails or returns unexpected data.
- */
-
-function getLastCommitHash() {
-  try {
-    const cmd = `curl --header "PRIVATE-TOKEN: ${readOnlyToken}" --url ${commitHashEndPoint}`;
-    return JSON.parse(execSync(cmd))[0]["id"];
-  } catch (err) {
-    Logger.log(Logger.FAILURE_TYPE, err);
-    return null;
-  }
-}
-
-/**
- * @function getRequiredInfoPath - Returns the absolute path to the `fsUtils.json` file located in the `jsonUtils` directory at the project root.
- * @returns {string} The full path to the `fsUtils.json` file.
- */
-
-function getRequiredInfoPath() {
-  return path.join(process.cwd(), 'jsonUtils', 'fsUtils.json');
-}
-
-/**
- * @function getStoredCommitHash - Loads and returns the stored commit hash from `fsUtils.json`.
- * @returns {string} The commit hash stored in the `fsUtils.json` file.
- * @throws {Error} Will throw if the file does not exist or does not contain a `commitHash` key.
- */
-
-function getStoredCommitHash() {
-  const commitInfoPath = path.join(__dirname, '..', '..', '..', 'jsonUtils', 'fsUtils.json');
-  return fs.existsSync(commitInfoPath) && require(commitInfoPath).commitHash;
-}
 module.exports = {
   getSupportedLanguage,
   getTimeStampInfo,
   getEnv,
   getConfigurationPrecommit,
-  getRunningEnv,
-  getLastCommitHash,
-  getRequiredInfoPath,
-  getStoredCommitHash
+  getRunningEnv
 };

package/build/utils/General/writeProjectDetailsToJson.js

@@ -7,16 +7,11 @@ const {
 const {
   executeSynchronizedCommands
 } = require('./executeSyncCommands');
-const {
-  getLastCommitHash,
-  getRequiredInfoPath
-} = require('./getGeneralInfo');
 function writeFsPaths() {
   var fileContent = {
-    nodeModulesPath: path.resolve(process.cwd(), '..', '..', '..'),
-    commitHash: getLastCommitHash()
+    nodeModulesPath: path.resolve(process.cwd(), '..', '..', '..')
   };
-  return executeSynchronizedCommands(writeFileSync, [getRequiredInfoPath(), JSON.stringify(fileContent), 'utf-8'], 'node_modules path updated in json file', 'Unable to write node_modules path to json file', false, true);
+  return executeSynchronizedCommands(writeFileSync, [path.join(process.cwd(), 'jsonUtils', 'fsUtils.json'), JSON.stringify(fileContent), 'utf-8'], 'node_modules path updated in json file', 'Unable to write node_modules path to json file', false, true);
 }
 module.exports = {
   writeFsPaths