@zohodesk/codestandard-validator 0.0.6-exp-6 → 0.0.6-exp-7

package/build/hooks/Precommit/lint.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 preCommitCheck() {
+  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 = preCommitCheck;

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

@@ -20,8 +20,8 @@ const {
   arePluginsInstalled
 } = require("../../utils/PluginsInstallation/arePluginsInstalled");
 const {
-  default: prePushCheck
-} = require("../PrePush/pre-push");
+  default: preCommitCheck
+} = require("./lint");
 async function validateRemotePackages() {
   try {
     if (!(getStoredCommitHash() == getLastCommitHash())) {
@@ -36,5 +36,5 @@ async function validateRemotePackages() {
 }
 (async function () {
   await validateRemotePackages();
-  await prePushCheck();
+  await preCommitCheck();
 })();

package/build/utils/HuskySetup/configurePrecommitHook.js

@@ -21,33 +21,17 @@ const {
  */
 function configurePrecommitHook() {
   let rootDirectory = getRootDirectory();
-  let customPrecomitHookPath = path.join(getLibraryInstalledLocation(), "bin", "precommit.js");
-
-  // let customPrePushHookPath = path.join(
-  //   getLibraryInstalledLocation(),
-  //   "bin",
-  //   "push.js"
-  // );
-
+  let customPrecomitHookPath = path.join(getLibraryInstalledLocation(), "bin", "execute.js");
   let huskyPrecommitPath = path.join(rootDirectory, ".husky", "pre-commit");
-  // let huskyPrePushPath  = path.join(rootDirectory,".husky","pre-push")  
   let huskyPrecommitHookContent = `#!/bin/sh
 . "$(dirname "$0")/_/husky.sh"
 
 "${customPrecomitHookPath}"
 `;
-
-  //   let huskyPrePushHookContent = `#!/bin/sh
-  // . "$(dirname "$0")/_/husky.sh"
-
-  // "${customPrePushHookPath}"
-  // ` 
   let isCustomPrecommitConfigurationSuccessful = executeSynchronizedCommands(writeFileSync, [huskyPrecommitPath, huskyPrecommitHookContent, 'utf-8'], '', 'Could not create and write pre-commit.sh inisde husky directory', false, true);
-  // let isCustomPrePushConfigurationSuccessful = executeSynchronizedCommands(writeFileSync, [huskyPrePushPath, huskyPrePushHookContent, 'utf-8'], '', 'Could not create and write pre-push.sh inisde husky directory', false, true);
   if (isCustomPrecommitConfigurationSuccessful) {
-    let isExecutionPermissionGivenSuccessfully_precommit = grantExecutionPermission([huskyPrecommitPath, customPrecomitHookPath]);
-    // let isExecutionPermissionGivenSuccessfully_prepush = grantExecutionPermission([huskyPrePushPath, customPrePushHookPath]);
-    return isExecutionPermissionGivenSuccessfully_precommit;
+    let isExecutionPermissionGivenSuccessfully = grantExecutionPermission([huskyPrecommitPath, customPrecomitHookPath]);
+    return isExecutionPermissionGivenSuccessfully;
   } else {
     return false;
   }

package/package.json

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

package/bin/push.js

@@ -1,4 +0,0 @@
-#!/usr/bin/env node
-
-
-// require('../build/hooks/PrePush/pre-push')