@zohodesk/codestandard-validator 1.1.4 → 1.2.4-exp-2

package/build/chunk/chunk_Restriction.js

@@ -0,0 +1,202 @@
+"use strict";
+
+var _process;
+const {
+  execSync
+} = require('child_process');
+const {
+  getModifiedLines
+} = require('@zohodesk/codestandard-analytics');
+const {
+  getBranchName
+} = require('../utils/GitActions/gitActions');
+const Logger = console;
+const path = require('path');
+const {
+  getConfigPath
+} = require('../../build/utils/General/getGeneralInfo');
+const {
+  getConfigPathExecute
+} = require('../utils/General/Config');
+const {
+  gitEndPoint: _gitEndPoint
+} = getConfigPath(getConfigPathExecute());
+const gitEndPoint = _gitEndPoint || 'https://zgit.csez.zohocorpin.com';
+const compareBranch = ((_process = process) === null || _process === void 0 || (_process = _process.env) === null || _process === void 0 ? void 0 : _process.CHUNK_BRANCH) || 'release';
+const configPath = path.resolve(process.cwd(), 'lint.config.js');
+function getGitProjectId() {
+  try {
+    const config = require(configPath);
+    return config.projectId;
+  } catch (err) {
+    Logger.log(`Failed to Fetch Chunk Details`);
+    process.exit(1);
+  }
+}
+const projectId = getGitProjectId();
+const token = process.env.ZGIT_TOKEN;
+const shouldEnable = parserBoolean(process.env.SHOULD_ENABLE_CHUNK);
+function isTestOrUATFile(file) {
+  const f = file.replace(/\\/g, "/");
+  if (f.endsWith(".spec.js") || f.endsWith(".test.js") || f.endsWith(".spec.ts") || f.endsWith(".test.ts") || f.endsWith(".feature") || f.endsWith(".properties")) {
+    return true;
+  }
+
+  // UAT folder check
+  if (f.includes("/uat/")) {
+    return true;
+  }
+  return false;
+}
+function parserBoolean(value) {
+  let defaultValue = false;
+  if (value == null || value == undefined) {
+    return defaultValue;
+  }
+  let AcceptedCase = new Set(["true", true]);
+  return AcceptedCase.has(value);
+}
+function requestUtilsCLI(command) {
+  return execSync(command, {
+    shell: true
+  });
+}
+function createBranchDiffChunk(branchName) {
+  var command;
+  const endPoint = `${gitEndPoint}/api/v4/projects/${projectId.toString()}/repository/compare?from=${compareBranch}&to=${branchName}`;
+  try {
+    command = `curl --header "PRIVATE-TOKEN:${token}" "${endPoint}"`;
+    return parserReleaseDiffRemoteAPI(JSON.parse(requestUtilsCLI(command).toString('utf-8')));
+  } catch (error) {
+    Logger.log(error);
+    Logger.log(`\n INFO : If you are using a VPN and encounter an SSL certification issue, ensure that the proxy is enabled for SSH and shell connections.`);
+    Logger.log(`\n Make sure that you have access to this repository`);
+  }
+}
+function parserReleaseDiffRemoteAPI(rawresponse) {
+  var formatted = [];
+  if (rawresponse !== null && rawresponse !== void 0 && rawresponse.diffs) {
+    formatted = rawresponse.diffs.map(changeset => {
+      if (isTestOrUATFile(changeset.new_path)) {
+        return null;
+      }
+      const {
+        modifiedLines,
+        removedLines
+      } = getModifiedLines(changeset.diff);
+      chunkSize.$modifieldLines += modifiedLines.length;
+      chunkSize.$removedLines += removedLines.length;
+      return {
+        file: changeset.new_path,
+        diff: {
+          modifiedLines,
+          removedLines
+        }
+      };
+    }).filter(item => item !== null);
+  }
+  return formatted;
+}
+function parseCombinedDiff(combinedDiffString) {
+  if (!combinedDiffString) {
+    return [];
+  }
+  const fileDiffChunks = combinedDiffString.split(/(?=diff --git a\/)/g);
+  const structuredDiffs = fileDiffChunks.map(chunk => {
+    const fileHeaderMatch = chunk.match(/^diff --git a\/(.*?) b\/(.*?)\n/);
+    if (!fileHeaderMatch) {
+      return null;
+    }
+    const filePath = fileHeaderMatch[1];
+    if (isTestOrUATFile(filePath)) {
+      return null;
+    }
+    const {
+      modifiedLines,
+      removedLines
+    } = getModifiedLines(chunk.trim());
+    chunkSize.$modifieldLines += modifiedLines.length;
+    chunkSize.$removedLines += removedLines.length;
+    return {
+      file: filePath,
+      diff: {
+        modifiedLines,
+        removedLines
+      }
+    };
+  }).filter(item => item !== null);
+  return structuredDiffs;
+}
+function runGitCommand(command) {
+  try {
+    const output = execSync(command, {
+      cwd: process.cwd(),
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'ignore'],
+      maxBuffer: 10 * 1024 * 1024
+    }).trim();
+    return parseCombinedDiff(output);
+  } catch (error) {
+    if (error.status === 128) {
+      return `ERROR: Git error executing command: '${command}'. Ensure you are in a Git repository and all references exist.`;
+    }
+    return undefined;
+  }
+}
+function getGitChangesets(currentBranch, releaseBranch, upstreamRemote = 'origin') {
+  const stagedDiffCommand = 'git diff --staged';
+  const stagedChangeset = {
+    git_command: stagedDiffCommand,
+    description: 'Changes staged in the index, ready to be committed.',
+    actual_output: runGitCommand(stagedDiffCommand)
+  };
+  const releaseComparison = {
+    git_command: "giff diff with release",
+    description: `Total difference between the tip of branch '${currentBranch}' and the tip of reference '${releaseBranch}'.`,
+    actual_output: createBranchDiffChunk(currentBranch)
+  };
+  const unpushedDiffCommand = `git diff ${upstreamRemote}/${currentBranch}...HEAD`;
+  const unpushedChangeset = {
+    git_command: unpushedDiffCommand,
+    description: `Changes from all local commits that have not been pushed (diff since common ancestor of HEAD and its upstream).`,
+    actual_output: runGitCommand(unpushedDiffCommand)
+  };
+  return {
+    stagedChangeset,
+    releaseComparison,
+    unpushedChangeset
+  };
+}
+if (shouldEnable) {
+  const myCurrentBranch = getBranchName();
+  const targetRelease = process.env.CHUNK_BRANCH || 'release';
+  const chunk_size_env = Number(process.env.CHUNK_SIZE) || 800;
+  const remoteName = 'origin';
+  const Logger = console;
+  const RED = '\x1b[31m';
+  const GREEN = '\x1b[32m';
+  const RESET = '\x1b[0m';
+  (async function () {
+    Logger.log(`****************************** Calculation Chunk Size *******************************`);
+    if (!(globalThis !== null && globalThis !== void 0 && globalThis.chunkSize)) {
+      globalThis.chunkSize = {
+        $modifieldLines: 0,
+        $removedLines: 0
+      };
+      try {
+        await getGitChangesets(myCurrentBranch, targetRelease, remoteName);
+        if (chunkSize.$modifieldLines <= chunk_size_env) {
+          Logger.log(`${GREEN}Your Chunk was ${chunkSize.$modifieldLines} and remaining size ${chunk_size_env - chunkSize.$modifieldLines}${RESET}`);
+        } else {
+          Logger.log(`${RED}Your Chunk was ${chunkSize.$modifieldLines} which exceeded the allowed limit ${chunk_size_env} ${RESET}`);
+          // process.exit(1)
+        }
+      } catch (e) {
+        console.log(e);
+        Logger.error("Execution failed. Ensure you are running this in a Node.js environment with the 'child_process' module and 'git' installed.");
+        Logger.error(e.message);
+      }
+      Logger.log(`*************************************************************************************`);
+    }
+  })();
+}

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

@@ -58,7 +58,7 @@ async function isMergeCommit() {
 
 async function getStagedFiles() {
   return new Promise((resolve, reject) => {
-    exec("git diff --staged --name-only", (error, stderr, stdout) => {
+    exec('git diff --staged --name-only', (error, stderr, stdout) => {
       if (error) {
         if (error != null) reject("Couldn't fetch staged files");
       } else if (stderr) {
@@ -73,7 +73,7 @@ async function getStagedFiles() {
 /**
  * @function {filterDeltedFileFromStagedFiles} - filter deleted staged files
  * @param {Array<string>} files - staged files
- * @returns 
+ * @returns
  */
 function filterDeltedFileFromStagedFiles(files) {
   return files.filter(file => {
@@ -109,7 +109,7 @@ async function lintFiles(filePath) {
 /**
  * @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 
+ * @returns {Array<string>} -  array of command line report as a string
  */
 
 function findEslintErrors(file) {
@@ -126,10 +126,15 @@ function findEslintErrors(file) {
             resolve(stderr.trim().split('\n'));
           } else if (error) {
             Logger.log(Logger.FAILURE_TYPE, error);
-            reject("Error executing eslint command");
+            reject('Error executing eslint command');
           } else {
             resolve([]);
           }
+        }, {
+          env: {
+            ...process.env,
+            CHUNK_SIZE: (globalThis === null || globalThis === void 0 ? void 0 : globalThis.chunkSize) ?? ''
+          }
         });
       });
     } else {
@@ -141,8 +146,8 @@ function findEslintErrors(file) {
 }
 
 /**
- * 
- * @param {*} params 
+ *
+ * @param {*} params
  */
 function findStyleLintErrors(filePath) {
   const configFilePath = path.resolve(getNodeModulesPath(), '.stylelintrc.js');
@@ -156,7 +161,7 @@ function findStyleLintErrors(filePath) {
           resolve(stdout.trim().split('\n'));
         } else if (error) {
           Logger.log(Logger.FAILURE_TYPE, error);
-          reject("Error executing stylelint command");
+          reject('Error executing stylelint command');
         } else {
           resolve([]);
         }
@@ -172,7 +177,7 @@ function findStyleLintErrors(filePath) {
  * @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 
+ * @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()} ${path.resolve(getRootDirectory(), file)}`;
@@ -194,13 +199,115 @@ async function calculateGitDiffForFile(branch_name, file) {
 function isOnlyWarningsPresentInFile(eslintErrorsPresent) {
   let severityOfEachErrorInFile = [];
   eslintErrorsPresent.map(error => {
-    let partsInString = error.split(" ");
+    let partsInString = error.split(' ');
     let severityOfError = partsInString.find(word => word === 'error' || word === 'warning' || word === '✖');
     severityOfEachErrorInFile.push(severityOfError);
   });
   return !(severityOfEachErrorInFile.includes('✖') || severityOfEachErrorInFile.includes('error'));
 }
 
+/**
+ * Parse git diff hunk headers into changed line ranges.
+ * @param {string[]} diffLines - raw git diff output lines
+ * @returns {Array<{start: number, end: number}>}
+ */
+function getChangedLineRanges(diffLines) {
+  return diffLines.filter(line => line.startsWith('@@')).map(line => {
+    const [startStr, countStr] = line.split(' ')[2].split(',');
+    const start = parseInt(startStr, 10);
+    const end = countStr !== undefined ? start + parseInt(countStr, 10) - 1 : start;
+    return {
+      start,
+      end
+    };
+  });
+}
+
+/**
+ * Extract only error/warning lines from eslint output (strip header & summary).
+ * @param {string[]} rawOutput
+ * @returns {string[]}
+ */
+function extractLintErrors(rawOutput) {
+  if (!rawOutput || rawOutput.length <= 2) return [];
+  return rawOutput.slice(1, rawOutput.length - 2);
+}
+
+/**
+ * Filter lint errors to those on changed lines or matching mandatory rules.
+ * @param {string[]} lintErrors - extracted error lines
+ * @param {Array<{start: number, end: number}>} ranges - changed line ranges
+ * @returns {string[]}
+ */
+function filterErrorsByChangedLines(lintErrors, ranges) {
+  const result = new Set();
+  for (const errorLine of lintErrors) {
+    const lineNum = parseInt(errorLine.trim().split(' ')[0].split(':')[0], 10);
+    if (MandatoryListRules.some(ruleId => errorLine.trim().includes(ruleId))) {
+      result.add(errorLine);
+      continue;
+    }
+    for (const {
+      start,
+      end
+    } of ranges) {
+      if (lineNum >= start && lineNum <= end) {
+        result.add(errorLine);
+        break;
+      }
+    }
+  }
+  return Array.from(result);
+}
+
+/**
+ * Determine whether errors should abort the commit.
+ * @param {string[]} errors
+ * @returns {boolean}
+ */
+function shouldErrorsAbortCommit(errors) {
+  if (errors.length === 0) return false;
+  if (shouldWarningsAbortCommit) return true;
+  return !isOnlyWarningsPresentInFile(errors);
+}
+
+/**
+ * Log lint errors for a file.
+ * @param {string} fileName
+ * @param {string[]} errors
+ */
+function logFileErrors(fileName, errors) {
+  Logger.log(Logger.FAILURE_TYPE, `\x1b[1m${fileName}\x1b[0m`);
+  for (const error of errors) {
+    Logger.log(Logger.FAILURE_TYPE, `\x1b[37m${error.trimEnd()}\x1b[0m`);
+  }
+}
+
+/**
+ * Process a single staged file: lint it, optionally filter by changed lines, and return whether to abort.
+ * @param {string} file - relative file path
+ * @param {string} currentBranch
+ * @returns {Promise<boolean>} - true if this file should cause an abort
+ */
+async function processFile(file, currentBranch) {
+  if (!getSupportedLanguage().includes(path.extname(file))) return false;
+  const rawErrors = await lintFiles(file);
+  if (!rawErrors || !file || typeof file !== 'string') return false;
+  const lintErrors = extractLintErrors(rawErrors);
+  if (lintErrors.length === 0) return false;
+  let relevantErrors;
+  if (impactBasedPrecommit) {
+    const diffLines = await calculateGitDiffForFile(currentBranch, file);
+    const ranges = getChangedLineRanges(diffLines);
+    relevantErrors = filterErrorsByChangedLines(lintErrors, ranges);
+  } else {
+    relevantErrors = lintErrors;
+  }
+  if (relevantErrors.length === 0) return false;
+  logFileErrors(file, relevantErrors);
+  return shouldErrorsAbortCommit(relevantErrors);
+}
+
 /**
  * @function {preCommitHook} - method execute pre commit hook
  * @returns {void}
@@ -209,142 +316,53 @@ function isOnlyWarningsPresentInFile(eslintErrorsPresent) {
 async function preCommitHook_default() {
   Logger.log(Logger.INFO_TYPE, '\n Executing pre commit hook...');
   Logger.log(Logger.INFO_TYPE, `working dir  : ${process.cwd()}`);
+
+  // Skip merge commits
   try {
-    let isMerge = await isMergeCommit();
+    await isMergeCommit();
     Logger.log(Logger.INFO_TYPE, 'Looks like you have merged. So skipping pre commit check');
     process.exit(0);
-  } catch (error) {
-    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");
-    }
+  } catch {
+    // Not a merge commit — continue
+  }
+  let currentBranch = '';
+  try {
+    currentBranch = await getBranchName();
+  } catch {
+    Logger.log(Logger.INFO_TYPE, 'Error fetching current branch');
+  }
+  let stagedFiles = [];
+  try {
+    stagedFiles = await getStagedFiles();
+  } catch {
+    Logger.log(Logger.INFO_TYPE, 'Error executing pre commit hook');
+    return;
+  }
+  if (!stagedFiles || stagedFiles.length === 0) {
+    Logger.log(Logger.INFO_TYPE, 'No files have been staged. Stage your files before committing');
+    return;
+  }
+  const {
+    JsFiles,
+    CssFiles
+  } = filterFiles(stagedFiles, ['.eslintrc.js'], true);
+  const filesToLint = [...JsFiles, ...CssFiles];
+  let shouldAbortCommit = false;
+  for (const file of filesToLint) {
     try {
-      staged_files = await getStagedFiles();
-      if (!staged_files.length == 0) {
-        const {
-          JsFiles: staged_filesJS,
-          CssFiles
-        } = filterFiles(staged_files, eslintConfigFiles, true);
-
-        // staged_filesJS = filterFiles(staged_filesJS,exemptionFiles) //this is the code for giving exemption to a file during pre commit
-        // if(staged_filesJS.length === 0){
-        //     Logger.log(Logger.SUCCESS_TYPE,`Commit Successful`)
-        //     process.exit(0)
-        // }
-
-        // CssFiles not Enabled For while 
-        areFilesStaged = true;
-        var stagedFiles = [...staged_filesJS];
-        for (let file in stagedFiles) {
-          let currentFileName = stagedFiles[file];
-          let changedLinesArray = [];
-          let eslintErrorsInChangedLines = new Set();
-          let isOnlyEslintWarningsPresentInFile = false;
-          if (getSupportedLanguage().includes(path.extname(stagedFiles[file]))) {
-            try {
-              var errorsInFile = await lintFiles(stagedFiles[file]);
-              // eslintErrorsInFile = impactBasedPrecommit == false ? filterWarningInFile(errorsInFile) : errorsInFile
-              if (stagedFiles[file] && typeof stagedFiles[file] == 'string') {
-                if (!errorsInFile.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, stagedFiles[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 < errorsInFile.length - 2; error++) {
-                      //errorsInFile[error].trim() - 69:26  error => Do not hardcode content. Use I18N key instead  no-hardcoding/no-hardcoding, 
-                      //errorsInFile[error].trim().split(' ')[0] => 69:26
-                      //errorsInFile[error].trim().split(' ')[0].split(':')[0] => 69
-
-                      let eslintErrorLineNumber = errorsInFile[error].trim().split(' ')[0].split(':')[0];
-                      if (MandatoryListRules.some(ruleId => errorsInFile[error].trim().includes(ruleId))) {
-                        eslintErrorsInChangedLines.add(errorsInFile[error]);
-                      }
-                      for (let lineNumber in changedLinesStartArray) {
-                        if (eslintErrorLineNumber >= changedLinesStartArray[lineNumber] && eslintErrorLineNumber <= changedLinesEndArray[lineNumber]) {
-                          eslintErrorsInChangedLines.add(errorsInFile[error]);
-                        }
-                      }
-                    }
-                    if (eslintErrorsInChangedLines.size > 0) {
-                      isOnlyEslintWarningsPresentInFile = isOnlyWarningsPresentInFile(Array.from(eslintErrorsInChangedLines));
-                      Logger.log(Logger.FAILURE_TYPE, `\x1b[1m${currentFileName}\x1b[0m`);
-                      for (let eslintError of Array.from(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 (errorsInFile.length > 0) {
-                      let startIndex = 1;
-                      let endIndex = errorsInFile.length - 2;
-                      let listOsEslintErrors = errorsInFile.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 lint 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 linter 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);
+      const shouldAbort = await processFile(file, currentBranch);
+      if (shouldAbort) shouldAbortCommit = true;
+    } catch (err) {
+      Logger.log(Logger.FAILURE_TYPE, err);
+      Logger.log(Logger.FAILURE_TYPE, 'Error in executing lint command');
     }
   }
+  if (shouldAbortCommit) {
+    Logger.log(Logger.FAILURE_TYPE, 'There are linter errors/warnings present. So commit is aborted.');
+    process.exit(1);
+  } else {
+    Logger.log(Logger.SUCCESS_TYPE, 'Commit Successful');
+    process.exit(0);
+  }
 }
 preCommitHook_default();

package/build/hooks/hook.js

@@ -24,11 +24,12 @@ const {
 const {
   ensurePluginsInstalled
 } = require('./Precommit/guard');
-const config = require(path.join(process.cwd(), 'lint.config.js'));
-process.env.SONARQUBE_EXTERNAL = config.metric_token;
-process.env.SONARQUBE = config.meticHandler_api_token;
-process.env.ZGIT_TOKEN = config.token;
-process.env.TOOL_TOKEN = config.toolToken;
+const {
+  initConfig,
+  getConfigPathExecute
+} = require('../utils/General/Config');
+require("../chunk/chunk_Restriction");
+initConfig(getConfigPathExecute());
 async function hooks() {
   var jsonFilePath = path.join(__dirname, '..', '..', 'jsonUtils', 'fsUtils.json');
   let latestCommit = getLastCommitHash();

package/build/lib/postinstall.js

@@ -15,27 +15,23 @@ const {
 const {
   executeMethodsThatReturnBooleanValue
 } = require('../utils/General/wrapperFunctionToExecuteAFunction');
-const {
-  arePluginsInstalled
-} = require('../utils/PluginsInstallation/arePluginsInstalled');
 const {
   isGitInitialized
 } = require('../utils/GitActions/gitActions');
 const {
   writeFsPaths
 } = require('../utils/General/writeProjectDetailsToJson');
-const path = require('path');
+const {
+  initConfig,
+  getConfigPathPostInstall
+} = require('../utils/General/Config');
+
 /**
  *  @function {postInstall} -  This methods setup husky and configuration for executing project
  *  @returns {void}
  */
 async function postInstall() {
-  var actualNodeMoulesPath = path.resolve(process.cwd(), '..', '..', '..');
-  const config = require(path.join(actualNodeMoulesPath, 'lint.config.js'));
-  process.env.SONARQUBE_EXTERNAL = config.metric_token;
-  process.env.SONARQUBE = config.meticHandler_api_token;
-  process.env.ZGIT_TOKEN = config.token;
-  process.env.TOOL_TOKEN = config.toolToken;
+  initConfig(getConfigPathPostInstall());
   try {
     await executeMethodsThatReturnBooleanValue('Some issue in writing node_modules path to json', writeFsPaths, null);
     isGitInitialized() ? await executeMethodsThatReturnBooleanValue('Some issue occurred in setting up husky.', setupHusky, null) : null;