@zohodesk/codestandard-validator 0.0.6 → 0.0.7

package/build/hooks/PrePush/pre-push.js

@@ -0,0 +1,247 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+const {
+  exec
+} = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const {
+  getEslintExecutablePath
+} = require('../../utils/EslintConfigFileUtils/getEslintExecutablePath');
+const {
+  getNodeModulesPath
+} = require('../../utils/General/getNodeModulesPath');
+const {
+  filterFiles
+} = require('../../utils/FileAndFolderOperations/filterFiles');
+const {
+  Logger
+} = 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();
+
+/**
+ * Checks if the current commit is a merge commit
+ * @returns {Promise<boolean>} True if it's a merge commit
+ */
+async function isMergeCommit() {
+  return new Promise(resolve => {
+    exec('git rev-parse -q --verify MERGE_HEAD', error => {
+      resolve(!error);
+    });
+  });
+}
+
+/**
+ * Gets staged files while filtering out deleted files
+ * @returns {Promise<string[]>} Array of staged file paths
+ */
+async function getStagedFiles() {
+  return new Promise((resolve, reject) => {
+    exec('git diff --staged --name-only', (error, stdout) => {
+      if (error) {
+        return reject("Couldn't fetch staged files");
+      }
+      const files = stdout.trim().split('\n').filter(Boolean);
+      resolve(filterDeletedFiles(files));
+    });
+  });
+}
+
+/**
+ * Filters out deleted files from the staged files list
+ * @param {string[]} files - Array of file paths
+ * @returns {string[]} Filtered array of existing files
+ */
+function filterDeletedFiles(files) {
+  return files.filter(file => {
+    const absolutePath = path.resolve(getRootDirectory(), file);
+    return fs.existsSync(absolutePath);
+  });
+}
+
+/**
+ * Runs ESLint on a specific file
+ * @param {string} file - File path to lint
+ * @returns {Promise<string[]>} ESLint output lines
+ */
+async function runEslintOnFile(file) {
+  const nodeModulesPath = getNodeModulesPath();
+  const eslintPath = getEslintExecutablePath();
+  const configPath = `${nodeModulesPath}/.eslintrc.js`;
+  if (!fs.existsSync(nodeModulesPath)) {
+    Logger.log(Logger.INFO_TYPE, 'node_modules not found');
+    return [];
+  }
+  if (!fs.existsSync(eslintPath)) {
+    Logger.log(Logger.INFO_TYPE, 'Eslint executable not found');
+    return [];
+  }
+  return new Promise(resolve => {
+    const command = `npx --ignore-existing "${eslintPath}" --config "${configPath}" --no-inline-config --resolve-plugins-relative-to="${nodeModulesPath}/node_modules" ${file}`;
+    exec(command, (error, stderr) => {
+      if (stderr) {
+        resolve(stderr.trim().split('\n'));
+      } else {
+        resolve([]);
+      }
+    });
+  });
+}
+
+/**
+ * Computes git diff for a file against current branch
+ * @param {string} branch - Current branch name
+ * @param {string} file - File path
+ * @returns {Promise<string[]>} Git diff output lines
+ */
+async function getGitDiff(branch, file) {
+  return new Promise((resolve, reject) => {
+    exec(`git diff -U0 ${branch.trim()} ${file}`, (error, stderr) => {
+      if (error) return reject(error);
+      resolve(stderr ? stderr.trim().split('\n') : []);
+    });
+  });
+}
+
+/**
+ * Extracts changed line ranges from git diff output
+ * @param {string[]} diffLines - Git diff output
+ * @returns {Array<{start: number, end: number}>} Array of changed line ranges
+ */
+function parseChangedLines(diffLines) {
+  return diffLines.filter(line => line.startsWith('@@')).map(line => {
+    const parts = line.split(' ')[2].split(',');
+    const start = parseInt(parts[0]);
+    const end = parts[1] ? start + parseInt(parts[1]) - 1 : start;
+    return {
+      start,
+      end
+    };
+  });
+}
+
+/**
+ * Filters ESLint errors to only include those in changed lines
+ * @param {string[]} eslintErrors - ESLint output lines
+ * @param {Array<{start: number, end: number}>} changedRanges - Changed line ranges
+ * @returns {string[]} Filtered ESLint errors
+ */
+function filterErrorsToChangedLines(eslintErrors, changedRanges) {
+  return eslintErrors.filter(error => {
+    const match = error.match(/^(\d+):/);
+    if (!match) return false;
+    const line = parseInt(match[1]);
+    return changedRanges.some(({
+      start,
+      end
+    }) => line >= start && line <= end);
+  });
+}
+
+/**
+ * Checks if ESLint output contains only warnings
+ * @param {string[]} eslintErrors - ESLint output lines
+ * @returns {boolean} True if only warnings are present
+ */
+function hasOnlyWarnings(eslintErrors) {
+  return eslintErrors.every(error => error.includes('warning'));
+}
+
+/**
+ * Processes a file based on impact-based precommit configuration
+ * @param {string} file - File path to process
+ * @param {string} branch - Current branch name
+ * @returns {Promise<boolean>} True if errors should abort commit
+ */
+async function processFile(file, branch) {
+  if (!getSupportedLanguage().includes(path.extname(file))) return false;
+  try {
+    const eslintOutput = await runEslintOnFile(file);
+    if (eslintOutput.length < 3) return false; // No meaningful errors
+
+    const errors = eslintOutput.slice(1, -2);
+    if (!impactBasedPrecommit) {
+      Logger.log(Logger.FAILURE_TYPE, `\x1b[1m${file}\x1b[0m`);
+      errors.forEach(err => Logger.log(Logger.FAILURE_TYPE, `\x1b[37m${err.trimEnd()}\x1b[0m`));
+      if (!shouldWarningsAbortCommit && hasOnlyWarnings(errors)) {
+        return false;
+      }
+      return true;
+    }
+    const diffOutput = await getGitDiff(branch, file);
+    const changedRanges = parseChangedLines(diffOutput);
+    const changedLineErrors = filterErrorsToChangedLines(errors, changedRanges);
+    if (changedLineErrors.length > 0) {
+      Logger.log(Logger.FAILURE_TYPE, `\x1b[1m${file}\x1b[0m`);
+      changedLineErrors.forEach(err => Logger.log(Logger.FAILURE_TYPE, `\x1b[37m${err.trimEnd()}\x1b[0m`));
+      if (!shouldWarningsAbortCommit && hasOnlyWarnings(changedLineErrors)) {
+        return false;
+      }
+      return true;
+    }
+  } catch (error) {
+    Logger.log(Logger.FAILURE_TYPE, `Error processing ${file}: ${error}`);
+  }
+  return false;
+}
+
+/**
+ * Main pre-push hook execution logic
+ */
+async function prePushCheck() {
+  Logger.log(Logger.INFO_TYPE, 'Executing pre commit hook...');
+  if (await isMergeCommit()) {
+    Logger.log(Logger.INFO_TYPE, 'Merge commit detected. Skipping checks.');
+    process.exit(0);
+  }
+  const pluginsStatus = checkIfPluginsAreInstalled();
+  if (pluginsStatus.uninstalledPlugins.length > 0) {
+    Logger.log(Logger.FAILURE_TYPE, 'Commit failed: Required plugins missing');
+    Logger.log(Logger.INFO_TYPE, 'Run: npx ZDPrecommit setupPlugins');
+    process.exit(1);
+  }
+  try {
+    const stagedFiles = await getStagedFiles();
+    if (stagedFiles.length === 0) {
+      Logger.log(Logger.INFO_TYPE, 'No staged files found');
+      process.exit(0);
+    }
+    const filteredFiles = filterFiles(stagedFiles, ['.eslintrc.js'], true);
+    const currentBranch = await getBranchName();
+    let shouldAbort = false;
+    for (const file of filteredFiles) {
+      const fileShouldAbort = await processFile(file, currentBranch);
+      if (fileShouldAbort) shouldAbort = true;
+    }
+    if (shouldAbort) {
+      Logger.log(Logger.FAILURE_TYPE, 'Commit aborted due to ESLint issues');
+      process.exit(1);
+    }
+    Logger.log(Logger.SUCCESS_TYPE, 'Commit successful');
+    process.exit(0);
+  } catch (error) {
+    Logger.log(Logger.FAILURE_TYPE, `Pre-commit hook failed: ${error}`);
+    process.exit(1);
+  }
+}
+var _default = exports.default = prePushCheck;

package/build/hooks/Precommit/lint.js

@@ -0,0 +1,211 @@
+"use strict";
+
+const {
+  exec
+} = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const {
+  getEslintExecutablePath
+} = require('../../utils/ConfigFileUtils/getEslintExecutablePath');
+const {
+  getNodeModulesPath
+} = require('../../utils/General/getNodeModulesPath');
+const {
+  filterFiles,
+  filterWarningInFile
+} = require('../../utils/FileAndFolderOperations/filterFiles');
+const {
+  Logger
+} = 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();
+
+/* ------------------------------------------
+   Git Helpers
+------------------------------------------ */
+
+function isMergeCommit() {
+  return new Promise((resolve, reject) => {
+    exec('git rev-parse -q --verify MERGE_HEAD', (err, stderr, stdout) => {
+      if (err) return reject(err.toString().trim());
+      resolve((stdout || stderr).trim());
+    });
+  });
+}
+function getStagedFiles() {
+  return new Promise((resolve, reject) => {
+    exec('git diff --staged --name-only', (err, stderr, stdout) => {
+      if (err) return reject("Couldn't fetch staged files");
+      const output = stderr || stdout;
+      if (!output.trim()) return resolve([]);
+      resolve(filterDeletedFiles(output.trim().split('\n')));
+    });
+  });
+}
+function filterDeletedFiles(files) {
+  return files.filter(file => fs.existsSync(path.resolve(getRootDirectory(), file)));
+}
+
+/* ------------------------------------------
+   Lint Helpers
+------------------------------------------ */
+
+function lintFiles(filePath) {
+  const ext = path.extname(filePath);
+  if (['.js', '.ts', '.tsx', '.jsx'].includes(ext)) {
+    return findEslintErrors(filePath);
+  }
+  if (['.css', '.scss'].includes(ext)) {
+    return findStyleLintErrors(filePath);
+  }
+  return Promise.resolve([]);
+}
+function findStyleLintErrors(filePath) {
+  const config = path.resolve(getNodeModulesPath(), '.stylelintrc.js');
+  const absolutePath = path.join(getRootDirectory(), filePath);
+  return new Promise((resolve, reject) => {
+    exec(`npx stylelint ${absolutePath} --config ${config}`, {
+      cwd: getNodeModulesPath()
+    }, (err, stderr) => {
+      if (stderr) return resolve(stderr.trim().split('\n'));
+      if (err) {
+        Logger.log(Logger.FAILURE_TYPE, err);
+        return reject('Error executing stylelint command');
+      }
+      resolve([]);
+    });
+  }).catch(err => {
+    Logger.log(Logger.FAILURE_TYPE, 'Issue linting CSS files');
+    return [];
+  });
+}
+function findEslintErrors(filePath) {
+  const eslintPath = getEslintExecutablePath();
+  const nodeModulesPath = getNodeModulesPath();
+  const eslintConfig = `${nodeModulesPath}/.eslintrc.js`;
+  if (!fs.existsSync(eslintPath)) {
+    Logger.log(Logger.INFO_TYPE, 'Eslint executable not found. Ensure eslint plugin is installed.');
+    return Promise.resolve([]);
+  }
+  return new Promise((resolve, reject) => {
+    const cmd = `npx --ignore-existing "${eslintPath}" --config "${eslintConfig}" --no-inline-config --resolve-plugins-relative-to="${nodeModulesPath}/node_modules" ${filePath}`;
+    exec(cmd, (err, stderr) => {
+      if (stderr) return resolve(stderr.trim().split('\n'));
+      if (err) {
+        Logger.log(Logger.FAILURE_TYPE, err);
+        return reject('Error executing eslint command');
+      }
+      resolve([]);
+    });
+  });
+}
+function calculateGitDiffForFile(branch, file) {
+  return new Promise((resolve, reject) => {
+    exec(`git diff -U0 ${branch.trim()} ${file}`, (err, stderr) => {
+      if (stderr) return resolve(stderr.trim().split('\n'));
+      if (err) return reject(err);
+    });
+  });
+}
+
+/* ------------------------------------------
+   Utility
+------------------------------------------ */
+
+function areAllPluginsInstalled() {
+  const {
+    uninstalledPlugins
+  } = checkIfPluginsAreInstalled();
+  console.log('unInstalledPlugins', uninstalledPlugins);
+  return uninstalledPlugins.length === 0;
+}
+function isOnlyWarningsPresent(errors) {
+  const severities = errors.map(e => e.split(' ').find(w => w === 'error' || w === 'warning'));
+  return !severities.includes('error');
+}
+
+/* ------------------------------------------
+   Main Execution
+------------------------------------------ */
+
+async function preCommitHook() {
+  Logger.log(Logger.INFO_TYPE, 'Executing pre commit hook...');
+  Logger.log(Logger.INFO_TYPE, `Working directory: ${process.cwd()}`);
+  try {
+    await isMergeCommit();
+    Logger.log(Logger.INFO_TYPE, 'Looks like you have merged. So skipping pre-commit check');
+    process.exit(0);
+  } catch {
+    if (!areAllPluginsInstalled()) {
+      Logger.log(Logger.FAILURE_TYPE, 'Commit failed due to missing eslint plugins');
+      Logger.log(Logger.INFO_TYPE, `Run \x1b[37mnpx ZDPrecommit setupPlugins\x1b[33m in the project root`);
+      process.exit(1);
+    }
+    let files = await getStagedFiles();
+    if (files.length === 0) {
+      Logger.log(Logger.INFO_TYPE, 'No files staged. Stage files before committing.');
+      return;
+    }
+    const currentBranch = await getBranchName().catch(() => '');
+    const filteredFiles = filterFiles(files, ['.eslintrc.js'], true);
+    let shouldAbort = false;
+    for (const file of filteredFiles) {
+      if (!getSupportedLanguage().includes(path.extname(file))) continue;
+      try {
+        const lintResults = await lintFiles(file);
+        if (lintResults.length === 0) continue;
+        let relevantErrors = [];
+        if (impactBasedPrecommit) {
+          const gitDiff = await calculateGitDiffForFile(currentBranch, file);
+          const changeHunks = gitDiff.filter(line => line.startsWith('@@'));
+          const ranges = changeHunks.map(h => {
+            const start = parseInt(h.split(' ')[2].split(',')[0]);
+            const len = parseInt(h.split(' ')[2].split(',')[1]) || 1;
+            return [start, start + len - 1];
+          });
+          for (const error of lintResults.slice(1, -2)) {
+            const lineNum = parseInt(error.trim().split(' ')[0].split(':')[0]);
+            if (ranges.some(([start, end]) => lineNum >= start && lineNum <= end)) {
+              relevantErrors.push(error);
+            }
+          }
+        } else {
+          relevantErrors = lintResults.slice(1, -2);
+        }
+        if (relevantErrors.length) {
+          const onlyWarnings = isOnlyWarningsPresent(relevantErrors);
+          Logger.log(Logger.FAILURE_TYPE, `\x1b[1m${file}\x1b[0m`);
+          relevantErrors.forEach(e => Logger.log(Logger.FAILURE_TYPE, `\x1b[37m${e.trimEnd()}\x1b[0m`));
+          if (shouldWarningsAbortCommit || !onlyWarnings) {
+            shouldAbort = true;
+          }
+        }
+      } catch (err) {
+        Logger.log(Logger.FAILURE_TYPE, err);
+      }
+    }
+    if (shouldAbort) {
+      Logger.log(Logger.FAILURE_TYPE, 'There are eslint errors/warnings. Aborting commit.');
+      process.exit(1);
+    }
+    Logger.log(Logger.SUCCESS_TYPE, 'Commit Successful');
+    process.exit(0);
+  }
+}
+preCommitHook();

package/build/setup/sample.config.js

@@ -8,13 +8,14 @@ const path = require("path");
  * @property {boolean} impactBased - Indicates if the linting is impact-based.
  * @property {string} lintReportPath - The path to the lint report JSON file.
  * @property {string} metricServerHost - The URL of the SonarQube server.
- * @property {string} meticHandler_api_token -  The token for authentication with the SonarQube server.
- * @property {string} metric_token - The token for authentication with the SonarQube server.
+ * @property {string} meticHandler_api_token -  The token to authenticate sonarQube apis.
+ * @property {string} metric_token - The token to authenticate sonarQube.
  * @property {string} gitEndPoint - API EndPoint for Git Actions
  * @property {string} tsConfigurationPath - The path of the ts configuration Path
  * @property {number} projectId - project id of repository
  * @property {boolean} impactBasedPrecommit - Indicates if the linting is impact-based in pre commit
  * @property {boolean} shouldWarningsAbortCommit - Indicates if eslint warnings should abort the commit
+ * @property {string} pushMetricsOnPreCommit -  Indicates to push metrics to sonarQube or not
  * @property {string} token - Encrypted Authentication Token
  * @property {string} compareBranch - Branch to compare diff
  */
@@ -23,15 +24,16 @@ module.exports = {
   ruleConfigurationPath: path.resolve(process.cwd(), ".eslintrc.js"),
   impactBased: true,
   lintReportPath: path.resolve(process.cwd(), "lint-report", "lintReport.json"),
-  metricServerHost: "https://client-linters.zohodesk.csez.zohocorpin.com",
-  meticHandler_api_token: "oyRcKJZxm2RkXytfAzVtmyRlLIftou5anC==",
-  metric_token: "zxh_9737850jh2l53ml17223929ihii73072j54j2260",
+  metricServerHost: "https://client-linters.zdesk.csez.zohocorpin.com",
+  meticHandler_api_token: "KIDfmI46KIDfmI4kYPU1",
+  metric_token: "zxh_371336m636584i54m662j6495h46228mkj6hihh8",
   branchDiffPath: path.resolve(process.cwd(), "diffBranch.json"),
   gitEndPoint: "https://zgit.csez.zohocorpin.com",
   tsConfigurationPath: path.resolve(process.cwd(), 'tsconfig.json'),
   projectId: `project-id`,
   impactBasedPrecommit: true,
   shouldWarningsAbortCommit: false,
+  pushMetricsOnPreCommit: true,
   token: "w-OkG3f5OOM1Rkly8phZ",
   compareBranch: 'release',
   supportedExtensions: ['.js', '.jsx', '.ts', '.tsx', '.properties']

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/PluginsInstallation/Worker/installPluginsByWoker.js

@@ -0,0 +1,38 @@
+"use strict";
+
+const {
+  Worker
+} = require('worker_threads');
+const {
+  Logger
+} = require('../../Logger/Logger');
+async function installPluginsByWorker(plugins) {
+  try {
+    const results = await Promise.all(plugins.map(pkg => runWorker({
+      packageName: pkg.packageName,
+      version: pkg.version
+    })));
+    Logger.log(Logger.SUCCESS_TYPE, 'Package are installed By from workers:', results.join('\n'));
+  } catch (error) {
+    Logger.log(Logger.FAILURE_TYPE, 'Error:', error);
+  }
+}
+function runWorker(data) {
+  return new Promise((resolve, reject) => {
+    const worker = new Worker(`${__dirname}/worker.js`, {
+      workerData: data
+    });
+    worker.on('message', result => {
+      resolve(result);
+    });
+    worker.on('error', error => {
+      reject(error);
+    });
+    worker.on('exit', code => {
+      if (code !== 0) {
+        reject(new Error(`Worker stopped with exit code ${code}`));
+      }
+    });
+  });
+}
+module.exports = installPluginsByWorker;

package/build/utils/PluginsInstallation/Worker/worker.js

@@ -0,0 +1,33 @@
+"use strict";
+
+const {
+  workerData,
+  parentPort
+} = require('worker_threads');
+const {
+  spawnSync
+} = require('child_process');
+const {
+  getNodeModulesPath
+} = require('../../General/getNodeModulesPath');
+function performanceInstalllation({
+  packageName,
+  version
+}) {
+  const start = performance.now();
+  try {
+    require.resolve(packageName);
+  } catch (err) {
+    spawnSync('npm', ['install', `${packageName}@${version}`, '--no-save'], {
+      stdio: 'inherit',
+      cwd: getNodeModulesPath()
+    });
+  }
+  const end = performance.now();
+  return `Package ${packageName}@${version} installed successfully and installed in ${end - start} ms`;
+}
+const result = performanceInstalllation({
+  packageName: workerData.packageName,
+  version: workerData.version
+});
+parentPort.postMessage(result);

package/jsonUtils/commonLinterRepoDetails.js

@@ -14,5 +14,10 @@ module.exports =  {
   cacheDirectory: "./",
   commonLinterRepoName: "configuration",
   type: "git",
-  user:"rajasekar.hm"
-};
+  user:"rajasekar.hm",
+  commitHashEndPoint:"https://zgit.csez.zohocorpin.com/api/v4/projects/19251/repository/commits",
+  readOnlyToken:"k-CyU3t5CCA1Fyzm8dvN"
+};
+
+
+

package/package.json

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