@zohodesk/codestandard-validator 0.0.7 → 1.0.0

package/.babelrc

@@ -4,7 +4,7 @@
       "@babel/preset-env",
       {
         "targets": {
-          "node": "14"
+          "node": "16"
         }
       }
     ]

package/bin/execute.js

@@ -1,3 +1,3 @@
 #!/usr/bin/env node
 
-require('../build/hooks/Precommit/pre-commit')
+require('../build/hooks/hook')

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

@@ -1,13 +1,14 @@
 "use strict";
 
 const {
-  exec
+  exec,
+  execSync
 } = require('child_process');
 const fs = require('fs');
 const path = require('path');
 const {
   getEslintExecutablePath
-} = require('../../utils/EslintConfigFileUtils/getEslintExecutablePath');
+} = require('../../utils/ConfigFileUtils/getEslintExecutablePath');
 const {
   getNodeModulesPath
 } = require('../../utils/General/getNodeModulesPath');
@@ -87,6 +88,27 @@ function filterDeltedFileFromStagedFiles(files) {
     return false;
   });
 }
+async function lintFiles(filePath) {
+  switch (String(path.extname(filePath))) {
+    case '.js':
+    case '.ts':
+    case '.tsx':
+    case '.jsx':
+    case '.properties':
+      {
+        return await findEslintErrors(filePath);
+      }
+    case '.css':
+    case '.scss':
+      {
+        return await findStyleLintErrors(filePath);
+      }
+    default:
+      {
+        return [];
+      }
+  }
+}
 
 /**
  * @function findEslintErrors - method  Lint given file based on given configuration
@@ -94,7 +116,7 @@ function filterDeltedFileFromStagedFiles(files) {
  * @returns {Array<string>} -  array of command line report as a string 
  */
 
-async function findEslintErrors(file) {
+function findEslintErrors(file) {
   let nodeModulesPathOfProject = `${getNodeModulesPath()}`;
   let eslintExecutablePath = getEslintExecutablePath();
   let eslintConfigurationFilePath = `${nodeModulesPathOfProject}/.eslintrc.js`;
@@ -121,6 +143,39 @@ async function findEslintErrors(file) {
     Logger.log(Logger.INFO_TYPE, 'node_modules not found');
   }
 }
+
+/**
+ * 
+ * @param {*} params 
+ */
+function findStyleLintErrors(filePath) {
+  const configFilePath = path.resolve(getNodeModulesPath(), '.stylelintrc.js');
+  const absolutePath = path.join(getRootDirectory(), filePath);
+  try {
+    return new Promise((resolve, reject) => {
+      exec(`npx stylelint ${absolutePath} --config ${configFilePath}`, {
+        cwd: getNodeModulesPath()
+      }, (error, stderr, stdout) => {
+        if (stdout) {
+          resolve(stdout.trim().split('\n'));
+        }
+        // if(stderr){
+        //     resolve(stderr.trim().split('\n'))
+        // }
+        else if (error) {
+          Logger.log(Logger.FAILURE_TYPE, error);
+          reject("Error executing stylelint command");
+        } else {
+          resolve([]);
+        }
+      });
+    });
+  } catch (error) {
+    Logger.log(Logger.FAILURE_TYPE, `Issue is lint css files`);
+    return [];
+  }
+}
+
 /**
  * @function {calculateGitDiffForFile} -  method calculate diff of file
  * @param {*} branch_name - branch name
@@ -157,10 +212,10 @@ function isOnlyWarningsPresentInFile(eslintErrorsPresent) {
   let severityOfEachErrorInFile = [];
   eslintErrorsPresent.map(error => {
     let partsInString = error.split(" ");
-    let severityOfError = partsInString.find(word => word === 'error' || word === 'warning');
+    let severityOfError = partsInString.find(word => word === 'error' || word === 'warning' || word === '✖');
     severityOfEachErrorInFile.push(severityOfError);
   });
-  return !severityOfEachErrorInFile.includes('error');
+  return !(severityOfEachErrorInFile.includes('✖') || severityOfEachErrorInFile.includes('error'));
 }
 
 /**
@@ -193,29 +248,35 @@ async function preCommitHook() {
       try {
         staged_files = await getStagedFiles();
         if (!staged_files.length == 0) {
-          staged_files = filterFiles(staged_files, eslintConfigFiles, true);
+          const {
+            JsFiles: staged_filesJS,
+            CssFiles
+          } = filterFiles(staged_files, eslintConfigFiles, true);
 
-          // staged_files = filterFiles(staged_files,exemptionFiles) //this is the code for giving exemption to a file during pre commit
-          // if(staged_files.length === 0){
+          // 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;
-          for (let file in staged_files) {
-            let currentFileName = staged_files[file];
+          var stagedFiles = [...staged_filesJS];
+          for (let file in stagedFiles) {
+            let currentFileName = stagedFiles[file];
             let changedLinesArray = [];
             let eslintErrorsInChangedLines = [];
             let isOnlyEslintWarningsPresentInFile = false;
-            if (getSupportedLanguage().includes(path.extname(staged_files[file]))) {
+            if (getSupportedLanguage().includes(path.extname(stagedFiles[file]))) {
               try {
-                var eslintErrorsInFile = await findEslintErrors(staged_files[file]);
-                // eslintErrorsInFile = impactBasedPrecommit == false ? filterWarningInFile(eslintErrorsInFile) : eslintErrorsInFile
-                if (staged_files[file] && typeof staged_files[file] == 'string') {
-                  if (!eslintErrorsInFile.length == 0) {
+                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, staged_files[file]);
+                      let git_diff = await calculateGitDiffForFile(current_branch, stagedFiles[file]);
                       changedLinesArray = git_diff.filter(line => line.startsWith('@@'));
                       let changedLinesStartArray = [];
                       let changedLinesEndArray = [];
@@ -229,15 +290,15 @@ async function preCommitHook() {
                           changedLinesEndArray.push(changesStartLine + parseInt(changesEndLine) - 1);
                         }
                       }
-                      for (let error = 1; error < eslintErrorsInFile.length - 2; error++) {
-                        //eslintErrorsInFile[error].trim() - 69:26  error => Do not hardcode content. Use I18N key instead  no-hardcoding/no-hardcoding, 
-                        //eslintErrorsInFile[error].trim().split(' ')[0] => 69:26
-                        //eslintErrorsInFile[error].trim().split(' ')[0].split(':')[0] => 69
+                      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 = eslintErrorsInFile[error].trim().split(' ')[0].split(':')[0];
+                        let eslintErrorLineNumber = errorsInFile[error].trim().split(' ')[0].split(':')[0];
                         for (let lineNumber in changedLinesStartArray) {
                           if (eslintErrorLineNumber >= changedLinesStartArray[lineNumber] && eslintErrorLineNumber <= changedLinesEndArray[lineNumber]) {
-                            eslintErrorsInChangedLines.push(eslintErrorsInFile[error]);
+                            eslintErrorsInChangedLines.push(errorsInFile[error]);
                           }
                         }
                       }
@@ -258,10 +319,10 @@ async function preCommitHook() {
                         }
                       }
                     } else {
-                      if (eslintErrorsInFile.length > 0) {
+                      if (errorsInFile.length > 0) {
                         let startIndex = 1;
-                        let endIndex = eslintErrorsInFile.length - 2;
-                        let listOsEslintErrors = eslintErrorsInFile.slice(startIndex, endIndex);
+                        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) {
@@ -282,7 +343,7 @@ async function preCommitHook() {
                 }
               } catch (err) {
                 Logger.log(Logger.FAILURE_TYPE, err);
-                Logger.log(Logger.FAILURE_TYPE, "Error in executing eslint command");
+                Logger.log(Logger.FAILURE_TYPE, "Error in executing lint command");
               }
             }
           }
@@ -293,14 +354,14 @@ async function preCommitHook() {
         Logger.log(Logger.INFO_TYPE, 'Error executing pre commit hook');
       }
       if (shouldAbortCommit) {
-        Logger.log(Logger.FAILURE_TYPE, `There are eslint errors/warnings present. So commit is aborted.`);
+        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 {
-      Logger.log(Logger.FAILURE_TYPE, 'Commit failed since some eslint plugins are not installed');
+      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.');
       process.exit(1);

package/build/hooks/hook.js

@@ -0,0 +1,40 @@
+"use strict";
+
+const {
+  getLastCommitHash,
+  getStoredCommitHash,
+  updateJsonFile
+} = require("../utils/General/getGeneralInfo");
+const {
+  executeMethodsThatReturnBooleanValue
+} = require("../utils/General/wrapperFunctionToExecuteAFunction");
+const {
+  cloneViaCdt
+} = require("../utils/CloneCommonLinterRepo/cloneViaCdt");
+const {
+  getPluginsToInstall
+} = require("../utils/PluginsInstallation/checkIfPluginsAreInstalled");
+const {
+  installPlugins
+} = require("../utils/PluginsInstallation/installPlugins");
+const path = require("path");
+const {
+  Logger
+} = require("../utils/Logger/Logger");
+async function hooks() {
+  var jsonFilePath = path.join(__dirname, '..', '..', 'jsonUtils', 'fsUtils.json');
+  if (!(getLastCommitHash() == getStoredCommitHash())) {
+    updateJsonFile(jsonFilePath, data => {
+      data.commitHash = getLastCommitHash();
+      return data;
+    });
+    Logger.log(Logger.INFO_TYPE, `Some rules and plugins are being fetched from a remote source and installed...`);
+    await executeMethodsThatReturnBooleanValue("Make sure zgit.csez.zohocorpin.com is accessible", cloneViaCdt, null);
+    const {
+      uninstalledPlugins
+    } = getPluginsToInstall();
+    await executeMethodsThatReturnBooleanValue("Some issue occurred in installing plugins", installPlugins, uninstalledPlugins);
+  }
+  require('./Precommit/pre-commit');
+}
+hooks();

package/build/lib/cli.js

@@ -16,7 +16,7 @@ const {
   installPlugins
 } = require("../utils/PluginsInstallation/installPlugins");
 const {
-  checkIfPluginsAreInstalled
+  getPluginsToInstall
 } = require("../utils/PluginsInstallation/checkIfPluginsAreInstalled");
 const [,, action, ...options] = process.argv;
 async function run() {
@@ -35,7 +35,7 @@ async function run() {
       {
         const {
           uninstalledPlugins
-        } = checkIfPluginsAreInstalled();
+        } = getPluginsToInstall();
         await executeMethodsThatReturnBooleanValue("Some issue occurred in installing plugins", installPlugins, uninstalledPlugins);
         break;
       }

package/build/lib/postinstall.js

@@ -7,8 +7,8 @@ const {
   setupHusky
 } = require("../utils/HuskySetup/setupHusky");
 const {
-  createEslintConfigFile
-} = require("../utils/EslintConfigFileUtils/createEslintConfigFile");
+  createConfigFile
+} = require("../utils/ConfigFileUtils/createConfigFile");
 const {
   Logger
 } = require("../utils/Logger/Logger");
@@ -34,7 +34,7 @@ async function postInstall() {
     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;
     await executeMethodsThatReturnBooleanValue("Make sure zgit.csez.zohocorpin.com is accessible", cloneViaCdt, null);
-    await executeMethodsThatReturnBooleanValue("Some issue occurred in creating eslint config file.", createEslintConfigFile, null);
+    await executeMethodsThatReturnBooleanValue("Some issue occurred in creating eslint config file.", createConfigFile, null);
     Logger.log(Logger.SUCCESS_TYPE, "Pre commit setup successfull");
     arePluginsInstalled();
   } catch (error) {

package/build/utils/CloneCommonLinterRepo/cloneViaCdt.js

@@ -16,14 +16,6 @@ const {
 const {
   executeSynchronizedCommands
 } = require('../General/executeSyncCommands');
-var {
-  type,
-  endPoint,
-  branch,
-  cacheDirectory,
-  commonLinterRepoName,
-  user
-} = require('../../../jsonUtils/commonLinterRepoDetails');
 const {
   getConfigurationPrecommit,
   getRunningEnv
@@ -34,28 +26,49 @@ const {
 const {
   Logger
 } = require("../Logger/Logger");
+const {
+  type,
+  endPoint,
+  branch,
+  cacheDirectory,
+  commonLinterRepoName,
+  user
+} = require('../../../jsonUtils/commonLinterRepoDetails');
+
 /**
- * @function cloneViaCdt - Using the "clint development tool" clones the common linter_configuration repo into precommit library
- * @returns {boolean} - indicating the success or failure of the cloning process
+ * @function cloneViaCdt
+ * @description Clones the common linter configuration repo using Clint Development Tool (CDT)
+ * @returns {boolean} Indicates the success or failure of the cloning process
  */
-
 function cloneViaCdt() {
-  const {
-    token
-  } = getConfigurationPrecommit();
-  removeFolder(getDeleteDirPath());
-  const userName = user;
-  var absoluteEndPoint = `https://${endPoint}`;
-  const runningEnv = getRunningEnv();
-  if (runningEnv === "CI" || runningEnv === "DEVAUTOMATION") {
-    Logger.log(Logger.INFO_TYPE, `Running in ${runningEnv}`);
-    absoluteEndPoint = `https://${userName}:${decrypt(token, process.env.DECRYPT_TOKEN)}@${endPoint}`;
+  try {
+    const {
+      token
+    } = getConfigurationPrecommit();
+    const currentEnv = getRunningEnv();
+    Logger.log(Logger.INFO_TYPE, `Application is running in the following environment:${currentEnv}`);
+
+    // Clean up existing folder
+    const deleteDir = getDeleteDirPath();
+    removeFolder(deleteDir);
+
+    // Construct endpoint with credentials if in CI or automation
+    const isAutomatedEnv = currentEnv === "CI" || currentEnv === "DEVAUTOMATION";
+    const authenticatedEndpoint = isAutomatedEnv ? `https://${user}:${decrypt(token, 12)}@${endPoint}` : `https://${endPoint}`;
+    const cloneCommand = ['npx cdt clone', `--clone:type=${type}`, `--clone:url=${authenticatedEndpoint}`, `--clone:branch=${branch}`, `--clone:cacheDir=${cacheDirectory}`, `--clone:proj:name=${commonLinterRepoName}`].join(' ');
+
+    // Execute the CDT command
+    const clonedDir = getClonedDirPath();
+    const successMessage = `Lint Configuration Cloned Successfully - ${getRepoName() || 'common'}`;
+    const errorMessage = 'Could not clone the linters common repo';
+    const result = executeSynchronizedCommands(execSync, [cloneCommand, {
+      cwd: clonedDir
+    }], successMessage, errorMessage, false, true);
+    return result;
+  } catch (error) {
+    Logger.log(Logger.ERROR_TYPE, `cloneViaCdt failed: ${error.message}`);
+    return false;
   }
-  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);
-  return isCommonConfigurationClonedSuccessfully;
 }
 module.exports = {
   cloneViaCdt

package/build/utils/ConfigFileUtils/createConfigFile.js

@@ -0,0 +1,63 @@
+"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');
+
+/**
+ * @function createConfigFile - creates ESLint and/or Stylelint configuration files based on repo config.
+ * @returns {boolean} - true if any config file is created successfully, false otherwise.
+ */
+function createConfigFile() {
+  const nodeModulesPath = getNodeModulesPath();
+  const eslintConfigFilePath = path.join(nodeModulesPath, '.eslintrc.js');
+  const stylelintConfigFilePath = path.join(nodeModulesPath, '.stylelintrc.js');
+  const {
+    pathOfServiceSpecificEslintConfigFile,
+    pathOfServiceSpecificCssConfigFile
+  } = getServicePathElseCommon();
+  try {
+    const eslintConfig = executeSynchronizedCommands(readFileSync, [pathOfServiceSpecificEslintConfigFile, 'utf-8'], '', 'Unable to read content of eslint config file.', true, false);
+    const cssConfig = executeSynchronizedCommands(readFileSync, [pathOfServiceSpecificCssConfigFile, 'utf-8'], '', 'Unable to read content of stylelint config file.', true, false);
+    const cssCreated = handleConfigFile(stylelintConfigFilePath, cssConfig, 'Stylelint');
+    const eslintCreated = handleConfigFile(eslintConfigFilePath, eslintConfig, 'Eslint');
+    return cssCreated || eslintCreated;
+  } catch (error) {
+    Logger.log(Logger.FAILURE_TYPE, error);
+    Logger.log(Logger.FAILURE_TYPE, 'Issue occurred while generating config files.');
+    return false;
+  }
+}
+
+/**
+ * @function handleConfigFile - handles deletion (if exists) and creation of config files.
+ * @param {string} filePath - Path to the config file.
+ * @param {string} configContent - Configuration content.
+ * @param {string} type - Type of configuration (e.g., Eslint, Stylelint).
+ * @returns {boolean}
+ */
+function handleConfigFile(filePath, configContent, type) {
+  if (existsSync(filePath)) {
+    executeSynchronizedCommands(unlinkSync, [filePath], `${type} configuration file removed successfully!`, `Unable to remove the ${type.toLowerCase()} config file.`, false, false);
+  }
+  return executeSynchronizedCommands(writeFileSync, [filePath, configContent, 'utf-8'], `${type} configuration file created successfully!`, `Unable to create and write a ${type.toLowerCase()} configuration file.`, false, true);
+}
+module.exports = {
+  createConfigFile
+};

package/build/utils/ConfigFileUtils/getLintConfiguration.js

@@ -29,12 +29,12 @@ function getServicePathElseCommon() {
   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');
+  let _cssLintConfig = 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
+    pathOfServiceSpecificCssConfigFile: _cssLintConfig
   };
 }
 function getLintConfigurationUtil() {

package/build/utils/FileAndFolderOperations/filterFiles.js

@@ -3,7 +3,9 @@
 const {
   Logger
 } = require('../Logger/Logger');
-
+const {
+  existsSync
+} = require("fs");
 /**
  * @function filterFiles - removes certain files from set of source files
  * @param {Array} arrayOfFilesToBeFiltered - array of files which must be filtered 
@@ -12,6 +14,29 @@ const {
  * @returns {Array} - containing the resultant set of files after filtering
  */
 function filterFiles(arrayOfFilesToBeFiltered, filesToBeRemoved, isConfigFileNeedToBeRemoved = false) {
+  /**
+   * @function filterFilesByExtension - filter javascript files. omit feature files
+   * @param {Array<String>} lintFiles - linter files as Array
+   * @returns {Array<String>} 
+   * */
+  function filterFilesByExtension(lintFiles) {
+    return lintFiles.reduce((files, currentFile) => {
+      if (currentFile.includes('.feature') && existsSync(currentFile)) {
+        files.featureFiles.push(currentFile);
+      }
+      if (currentFile.includes('.js') || currentFile.includes('.ts') || currentFile.includes('.tsx') || currentFile.includes('.jsx') || currentFile.includes('.properties') && existsSync(currentFile)) {
+        files.JsFiles.push(currentFile);
+      }
+      if (currentFile.includes('.css') && existsSync(currentFile)) {
+        files.CssFiles.push(currentFile);
+      }
+      return files;
+    }, {
+      featureFiles: [],
+      JsFiles: [],
+      CssFiles: []
+    });
+  }
   if (filesToBeRemoved.length !== 0) {
     if (isConfigFileNeedToBeRemoved) {
       arrayOfFilesToBeFiltered.filter(file => {
@@ -31,7 +56,7 @@ function filterFiles(arrayOfFilesToBeFiltered, filesToBeRemoved, isConfigFileNee
         return false;
       }
     });
-    return filteredArrayofFilesWithoutConfigFile;
+    return filterFilesByExtension(filteredArrayofFilesWithoutConfigFile);
   } else if (filesToBeRemoved.length === 0) {
     return arrayOfFilesToBeFiltered;
   }

package/build/utils/General/getGeneralInfo.js

@@ -6,6 +6,13 @@ const fs = require("fs");
 const {
   execSync
 } = require('child_process');
+const {
+  readOnlyToken,
+  commitHashEndPoint
+} = require('../../../jsonUtils/commonLinterRepoDetails');
+const {
+  Logger
+} = require('../Logger/Logger');
 
 /**
  * @function getTimeStampInfo - to fetch various timestamp details
@@ -57,8 +64,14 @@ function getSupportedLanguage() {
   const {
     supportedExtensions
   } = getConfigurationPrecommit();
-  const _language = supportedExtensions;
-  return _language;
+  const _language = supportedExtensions || [];
+  _language.push('.js');
+  _language.push('.jsx');
+  _language.push('.ts');
+  _language.push('.tsx');
+  _language.push('.css');
+  _language.push('.scss');
+  return [...new Set(_language)];
 }
 function getRunningEnv() {
   const command = "npm config get lint_env";
@@ -66,10 +79,58 @@ function getRunningEnv() {
     shell: true
   }).toString().trim();
 }
+
+/**
+ * @function getLastCommitHash - Fetches the last commit hash from a GitLab project using its API.
+ * 
+ * @note This function assumes access to a specific GitLab instance and a hardcoded token and project ID.
+ * @returns {string} The latest commit hash (SHA) from the specified GitLab repository.
+ * @throws {Error} Will throw an error if the API request fails or returns unexpected data.
+ */
+
+function getLastCommitHash() {
+  try {
+    var _JSON$parse$;
+    const cmd = `curl --header "PRIVATE-TOKEN: ${readOnlyToken}" --url ${commitHashEndPoint}`;
+    return (_JSON$parse$ = JSON.parse(execSync(cmd))[0]) === null || _JSON$parse$ === void 0 ? void 0 : _JSON$parse$.id;
+  } catch (err) {
+    Logger.log(Logger.FAILURE_TYPE, err);
+    return null;
+  }
+}
+
+/**
+ * @function getStoredCommitHash - Loads and returns the stored commit hash from `fsUtils.json`.
+ * @returns {string} The commit hash stored in the `fsUtils.json` file.
+ * @throws {Error} Will throw if the file does not exist or does not contain a `commitHash` key.
+ */
+
+function getStoredCommitHash() {
+  const commitInfoPath = getJsonUtilsPath();
+  return fs.existsSync(commitInfoPath) && require(commitInfoPath).commitHash;
+}
+function getJsonUtilsPath() {
+  return path.join(__dirname, '..', '..', '..', 'jsonUtils', 'fsUtils.json');
+}
+function updateJsonFile(filePath, modifier) {
+  try {
+    const absolutePath = path.resolve(filePath);
+    const rawData = fs.readFileSync(absolutePath, "utf-8");
+    const jsonData = JSON.parse(rawData);
+    const updatedData = modifier(jsonData);
+    fs.writeFileSync(absolutePath, JSON.stringify(updatedData, null, 2), "utf-8");
+  } catch (error) {
+    Logger.log(Logger.FAILURE_TYPE, "Error updating JSON file");
+  }
+}
 module.exports = {
   getSupportedLanguage,
   getTimeStampInfo,
   getEnv,
   getConfigurationPrecommit,
-  getRunningEnv
+  getRunningEnv,
+  getLastCommitHash,
+  getStoredCommitHash,
+  getJsonUtilsPath,
+  updateJsonFile
 };

package/build/utils/General/getNodeModulesPath.js

@@ -1,13 +1,16 @@
 "use strict";
 
 const path = require('path');
+const {
+  getJsonUtilsPath
+} = require('./getGeneralInfo');
 
 /**
  * @function getNodeModulesPath - fetches the absolute path where node_modules of project is present
  * @returns {string} - path where node_modules of the project is present
  */
 function getNodeModulesPath() {
-  return require(path.join(__dirname, '..', '..', '..', 'jsonUtils', 'fsUtils.json')).nodeModulesPath;
+  return require(getJsonUtilsPath()).nodeModulesPath;
 }
 module.exports = {
   getNodeModulesPath

package/build/utils/General/writeProjectDetailsToJson.js

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