@zohodesk/codestandard-validator 1.1.3 → 1.2.4-exp-1

package/build/chunk/chunk_Restriction.js

@@ -0,0 +1,193 @@
+"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 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(`******************************** Experimental Phase 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/lint.js

@@ -102,14 +102,7 @@ async function runLintWorkflow(files, branch) {
   const execute = new Execution(EsLint, SonarQube, cliobj);
   await execute.executeLintHandler().finally(async () => {
     await execute.executeMetricHandler();
-    /**
-     *  global.analytics.totalIssues = global.analytics.totalIssues + 1;
-        global.analytics.status = "FAILURE";
-        global.analytics.message = 'Issues are detected, please review and resolve the errors'
-     */
-    // const { issues, hasIssue, totalIssues } = fetchProjectIssuesViaCurl("projectName");
   });
-  // Logger.log(Logger.INFO_TYPE,global.analytics)
   return global.analytics.status == 'FAILURE' ? true : false;
 }
 module.exports = {

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

@@ -17,9 +17,6 @@ const {
 const {
   Logger
 } = require('../../utils/Logger/Logger');
-const {
-  checkIfPluginsAreInstalled
-} = require('../../utils/PluginsInstallation/checkIfPluginsAreInstalled');
 const {
   getBranchName
 } = require('../../utils/GitActions/gitActions');
@@ -189,15 +186,6 @@ async function calculateGitDiffForFile(branch_name, file) {
     });
   });
 }
-/**
- * @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
@@ -226,143 +214,136 @@ async function preCommitHook_default() {
     Logger.log(Logger.INFO_TYPE, 'Looks like you have merged. So skipping pre commit check');
     process.exit(0);
   } catch (error) {
-    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) {
-          const {
-            JsFiles: staged_filesJS,
-            CssFiles
-          } = filterFiles(staged_files, eslintConfigFiles, true);
+    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) {
+        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)
-          // }
+        // 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);
-                        }
+        // CssFiles not Enabled For while 
+        areFilesStaged = true;
+        var stagedFiles = [...staged_filesJS, ...CssFiles];
+        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
+                    }
+                    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))) {
+                      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]);
                         }
-                        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;
-                        }
+                    }
+                    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`);
                       }
-                    } 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;
-                        }
+                      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");
               }
+            } 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);
+      } else if (staged_files.length === 0) {
+        Logger.log(Logger.INFO_TYPE, 'No files have been staged. Stage your files before committing');
       }
-    } else {
-      Logger.log(Logger.FAILURE_TYPE, 'Commit failed since some lint 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.');
+    } 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);
     }
   }
 }

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();
@@ -47,10 +48,10 @@ async function hooks() {
     } = getPluginsToInstall();
     await executeMethodsThatReturnBooleanValue('Some issue occurred in installing plugins', installPlugins, uninstalledPlugins);
   }
-  if (process.env.CLIPRECOMMIT && Boolean(process.env.CLIPRECOMMIT) == true) {
-    require('./Precommit/pre-commit-default');
-  } else {
+  if (process.env.PUSHTOSONARQUBE && Boolean(process.env.PUSHTOSONARQUBE) == true) {
     require('./Precommit/commit');
+  } else {
+    require('./Precommit/pre-commit-default');
   }
 }
 hooks();

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;

package/build/utils/General/Config.js

@@ -0,0 +1,21 @@
+"use strict";
+
+const path = require('path');
+function initConfig(actualConfigPath) {
+  const config = require(path.join(actualConfigPath, '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;
+}
+function getConfigPathPostInstall() {
+  return path.resolve(process.cwd(), '..', '..', '..');
+}
+function getConfigPathExecute() {
+  return path.resolve(process.cwd());
+}
+module.exports = {
+  initConfig,
+  getConfigPathExecute,
+  getConfigPathPostInstall
+};

package/build/utils/General/Hash.js

@@ -1,9 +1,5 @@
 "use strict";
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.encrypt = exports.decrypt = void 0;
 const caesarCipher = (str, shift) => {
   return str.split("").map(char => {
     let code = char.charCodeAt();
@@ -16,6 +12,8 @@ const caesarCipher = (str, shift) => {
   }).join("");
 };
 const encrypt = (plaintext, shift) => caesarCipher(plaintext, shift);
-exports.encrypt = encrypt;
 const decrypt = (ciphertext, shift) => caesarCipher(ciphertext, 26 - shift);
-exports.decrypt = decrypt;
+module.exports = {
+  encrypt,
+  decrypt
+};

package/build/utils/General/SonarQubeUtil.js

@@ -78,7 +78,7 @@ async function fetchProjectIssuesViaCurl(componentKey) {
   _Logger.Logger.log(_Logger.Logger.INFO_TYPE, `\n Fetching issues (curl) for component: ${componentKey}`);
   const url = buildIssuesSearchUrl(componentKey);
   try {
-    const token = process.env.SONARQUBE; //'sqa_1f6675c05f63c4784dc741ce751efa0066d2693c' || decrypt(getAPIToken(), ); // sonarqube
+    const token = process.env.SONARQUBE;
     const command = `curl --tlsv1.2 -s -u "${token}:" "${url}"`;
     const output = execSync(command).toString();
     const json = JSON.parse(output.toString());

package/changeLog.md

@@ -41,4 +41,9 @@
 
 # 1.1.3 - SonarQube Enable
 
-1. Remote Installtion flow moved to before and handled process.exit removed
+1. Remote Installtion flow moved to before and handled process.exit removed
+
+# 1.1.4 - Minor Bug Fixes
+
+1. ProjectId api revamp
+2. code standard analytics bin bind to code standard validator bin

package/jest.config.js

@@ -1,5 +1,5 @@
 module.exports = {
   testEnvironment: 'node',
   clearMocks: true,
-  setupFilesAfterEnv: ['<rootDir>/jest.setup.js'],
+  setupFilesAfterEnv: ['<rootDir>/jest.setup.js']
 };