@zohodesk/codestandard-validator 1.2.4-exp-5 → 1.2.4-exp-7

package/build/mutation/branchDiff.js

@@ -4,175 +4,250 @@ const {
   execSync
 } = require('child_process');
 const path = require('path');
-class BranchDiff {
-  constructor(options = {}) {
-    this._cwd = options.cwd || process.cwd();
-    this._api = options.api || null;
-    this._patToken = options.patToken || null;
-    this._sourceExtensions = options.sourceExtensions || ['.js', '.ts', '.jsx', '.tsx', '.mjs', '.cjs'];
-    this._testPattern = options.testPattern || /\.(test)\.(js|ts|jsx|tsx|mjs|cjs)$/;
+const fs = require('fs');
+const {
+  writeFileSync
+} = require('fs');
+
+/**
+ * BranchDiff — git-based file change detection.
+ *
+ * Provides two use-cases:
+ *   1. Local / pre-commit  — staged files  +  diff vs release branch
+ *   2. CI                  — diff vs release branch only
+ *
+ * Compatible with Node 16+.
+ */
+function BranchDiff(options) {
+  this.options = options || {};
+  this._cwd = options.cwd || process.cwd();
+  this._sourceExtensions = options.sourceExtensions || ['.js', '.ts', '.jsx', '.tsx', '.mjs', '.cjs'];
+  this._testPattern = options.testPattern || /\.(test|spec)\.(js|ts|jsx|tsx|mjs|cjs)$/;
+  this.rootDirectory = this.getRootDirectory();
+  this._token = options.token || null;
+  this._gitEndPoint = options.gitEndPoint || null;
+  this._branchDiffPath = options.branchDiffPath || null;
+  this._compareBranch = options.compareBranch || null;
+  this._projectId = options.projectId || null;
+}
+
+/* ------------------------------------------------------------------ */
+/*  Internal git helpers                                                */
+/* ------------------------------------------------------------------ */
+
+BranchDiff.prototype._sanitizeBranch = function (branch) {
+  return String(branch).replace(/[^a-zA-Z0-9_\-.\/]/g, '');
+};
+BranchDiff.prototype._getCurrentBranch = function () {
+  try {
+    return execSync('git rev-parse --abbrev-ref HEAD', {
+      cwd: this._cwd,
+      encoding: 'utf-8'
+    }).trim();
+  } catch (err) {
+    throw new Error('Failed to get current branch: ' + err.message);
   }
-  _getCurrentBranch() {
-    try {
-      return execSync('git rev-parse --abbrev-ref HEAD', {
-        cwd: this._cwd,
-        encoding: 'utf-8'
-      }).trim();
-    } catch (err) {
-      throw new Error(`Failed to get current branch: ${err.message}`);
-    }
+};
+BranchDiff.prototype._fetchBranch = function (branch) {
+  var safeBranch = this._sanitizeBranch(branch);
+  try {
+    execSync('git fetch origin ' + safeBranch, {
+      cwd: this._cwd,
+      encoding: 'utf-8',
+      stdio: 'pipe'
+    });
+  } catch (_) {
+    // Branch might already be available locally — ignore
+  }
+};
+/**
+ * Get the root directory of the git repository.
+ *
+ * @returns {string} absolute path to the git repo root
+ */
+BranchDiff.prototype.getRootDirectory = function () {
+  try {
+    return execSync('git rev-parse --show-toplevel', {
+      cwd: this._cwd,
+      encoding: 'utf-8',
+      stdio: 'pipe'
+    }).trim();
+  } catch (err) {
+    throw new Error('Failed to get git root directory: ' + err.message);
   }
-  _fetchBranch(branch) {
+};
+BranchDiff.prototype._resolveBranchRef = function (branch) {
+  var safeBranch = this._sanitizeBranch(branch);
+  var candidates = [safeBranch, 'origin/' + safeBranch];
+  for (var i = 0; i < candidates.length; i++) {
     try {
-      execSync(`git fetch origin ${branch}`, {
+      execSync('git rev-parse --verify ' + candidates[i], {
         cwd: this._cwd,
         encoding: 'utf-8',
         stdio: 'pipe'
       });
-    } catch (err) {
-      // Branch might already be available locally
+      return candidates[i];
+    } catch (_) {
+      // try next
     }
   }
-  _resolveBranchRef(branch) {
-    // Check if the ref exists locally
-    const candidates = [branch, `origin/${branch}`];
-    for (const ref of candidates) {
-      try {
-        execSync(`git rev-parse --verify ${ref}`, {
-          cwd: this._cwd,
-          encoding: 'utf-8',
-          stdio: 'pipe'
-        });
-        return ref;
-      } catch {
-        // try next
-      }
-    }
-    throw new Error(`Branch '${branch}' not found locally or as 'origin/${branch}'. ` + `Run 'git fetch origin ${branch}' or check the branch name.`);
+  throw new Error("Branch '" + branch + "' not found locally or as 'origin/" + branch + "'. " + "Run 'git fetch origin " + branch + "' or check the branch name.");
+};
+
+/* ------------------------------------------------------------------ */
+/*  Public API                                                          */
+/* ------------------------------------------------------------------ */
+
+/**
+ * Get files that differ between the current branch and a release/target branch
+ * using the GitLab compare API via curl.
+ *
+ * @param {string} releaseBranch - e.g. 'release', 'main'
+ * @returns {Promise<string[]>} list of changed file paths (relative to repo root)
+ */
+BranchDiff.prototype.getChangedFilesFromRelease = function (releaseBranch) {
+  var self = this;
+  var projectId = self._projectId;
+  var gitEndPoint = self._gitEndPoint;
+  var branchDiffPath = self._branchDiffPath;
+  var compareBranch = self._compareBranch || releaseBranch;
+  if (!projectId || !gitEndPoint) {
+    console.log('GitLab API config missing (projectId or gitEndPoint). Returning empty diff.');
+    return Promise.resolve([]);
   }
-  _getDiffFiles(targetBranch) {
-    const currentBranch = this._getCurrentBranch();
-    this._fetchBranch(targetBranch);
-    const resolvedRef = this._resolveBranchRef(targetBranch);
-    let diffRef;
-    try {
-      const mergeBase = execSync(`git merge-base ${resolvedRef} ${currentBranch}`, {
-        cwd: this._cwd,
-        encoding: 'utf-8'
-      }).trim();
-      diffRef = mergeBase;
-    } catch {
-      diffRef = resolvedRef;
-    }
+  if (projectId === 'project-id' || isNaN(Number(projectId))) {
+    console.log('Make sure that project id is properly configured');
+    return Promise.resolve([]);
+  }
+  console.log('projectId:', projectId);
+  var currentBranch = self._getCurrentBranch();
+  var endPoint = gitEndPoint + '/api/v4/projects/' + projectId.toString() + '/repository/compare?from=' + compareBranch + '&to=' + currentBranch;
+  return new Promise(function (resolve, reject) {
     try {
-      const output = execSync(`git diff --name-only --diff-filter=ACMR ${diffRef}`, {
-        cwd: this._cwd,
+      var command = 'curl --header "PRIVATE-TOKEN:' + self.options.token + '" "' + endPoint + '"';
+      var output = execSync(command, {
+        shell: true,
         encoding: 'utf-8'
       });
-      return output.split('\n').map(f => f.trim()).filter(f => f.length > 0);
-    } catch (err) {
-      throw new Error(`Failed to get diff files against branch '${targetBranch}': ${err.message}`);
-    }
-  }
-  _getDiffFilesFromApi(targetBranch) {
-    if (!this._api || !this._patToken) {
-      throw new Error('API and PAT token are required for API-based diff');
-    }
-    // Placeholder for API-based diff (e.g., Azure DevOps, GitHub, etc.)
-    // Consumers can pass in their own api object that implements `getChangedFiles(targetBranch, patToken)`
-    if (typeof this._api.getChangedFiles === 'function') {
-      return this._api.getChangedFiles(targetBranch, this._patToken);
-    }
-    throw new Error('API object must implement getChangedFiles(targetBranch, patToken)');
-  }
-
-  /**
-   * Fetches branch diff from GitLab compare API via HTTPS
-   * @param {string} hostname - GitLab host (e.g. 'gitlab.example.com')
-   * @param {string} branch - Target branch to compare against
-   * @returns {Promise<string[]>} - Array of changed file paths
-   */
-  _fetchBranchDiffFromApi(hostname, branch, projectId) {
-    const currentBranch = this._getCurrentBranch();
-    const patToken = this._patToken || process.env.ZGIT_TOKEN;
-    if (!patToken) {
-      return reject(new Error('PAT token is required. Set it via options.patToken or ZGIT_TOKEN env var'));
-    }
-    if (!projectId) {
-      return reject(new Error('GitLab projectId is required for API-based diff'));
-    }
-    const createBranchDiffChunk = (resolve, reject) => {
-      // code duplicate need find solution
-      var command;
-      const endPoint = `${hostname}/api/v4/projects/${encodeURIComponent(projectId)}/repository/compare?from=${branch}&to=${currentBranch}`;
-      try {
-        command = `curl --header "PRIVATE-TOKEN:${patToken}" "${endPoint}"`;
-        return resolve(parserReleaseDiffRemoteAPI(JSON.parse(execSync(command, {
-          cwd: this._cwd
-        }))));
-      } 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`);
-        reject(error);
+      if (branchDiffPath) {
+        writeFileSync(branchDiffPath, output);
       }
-    };
-    function parserReleaseDiffRemoteAPI(rawresponse) {
-      var formatted = [];
-      if (rawresponse !== null && rawresponse !== void 0 && rawresponse.diffs) {
-        formatted = rawresponse.diffs.map(changeset => {
-          return changeset === null || changeset === void 0 ? void 0 : changeset.new_path;
-        }).filter(Boolean);
+      var response = JSON.parse(output);
+      var diffs = response.diffs || [];
+      var files = diffs.map(function (d) {
+        return d.new_path || d.old_path;
+      }).filter(function (f) {
+        return f && f.length > 0;
+      });
+
+      // deduplicate
+      var seen = {};
+      var unique = [];
+      for (var i = 0; i < files.length; i++) {
+        if (!seen[files[i]]) {
+          seen[files[i]] = true;
+          unique.push(files[i]);
+        }
       }
-      return formatted;
+      resolve(unique);
+    } catch (err) {
+      console.log('INFO : If you are using a VPN and encounter an SSL certification issue, ensure that the proxy is enabled for SSH and shell connections.');
+      console.log('Failed to get diff files from GitLab API: ' + err.message);
+      reject(new Error('Failed to get diff files from GitLab API: ' + err.message));
     }
-    return new Promise((resolve, reject) => {
-      return createBranchDiffChunk(resolve, reject);
+  });
+};
+
+/**
+ * Get staged (git add) file paths.
+ *
+ * @returns {string[]} list of staged file paths
+ */
+BranchDiff.prototype.getStagedFiles = function () {
+  try {
+    var output = execSync('git diff --staged --name-only', {
+      cwd: this._cwd,
+      encoding: 'utf-8'
     });
+    return output.trim().split('\n').filter(Boolean).filter(function (_path) {
+      return fs.existsSync(path.resolve(this.rootDirectory, _path));
+    }.bind(this));
+  } catch (err) {
+    throw new Error("Couldn't fetch staged files: " + err.message);
   }
-  async getStagedFiles() {
-    try {
-      const stdout = await execSync("git diff --staged --name-only").toString();
-      const files = stdout.trim().split("\n").filter(Boolean);
-      return files;
-    } catch (error) {
-      console.log(error);
-      throw new Error("Couldn't fetch staged files");
-    }
-  }
-  async getChangedFiles(targetBranch, options = {}) {
-    let allFiles;
-    if (options.useApi && options.hostname && options.projectId) {
-      allFiles = await this._fetchBranchDiffFromApi(options.hostname, targetBranch, options.projectId).concat(await this.getStagedFiles());
-    } else {
-      allFiles = this._getDiffFiles(targetBranch);
-    }
-    return this._categorizeFiles(allFiles);
-  }
-  _isSourceFile(filePath) {
-    const ext = path.extname(filePath);
-    if (!this._sourceExtensions.includes(ext)) {
-      return false;
+};
+
+/**
+ * LOCAL mode — combines staged files + release branch diff.
+ * Returns deduplicated, categorized { sourceFiles, testFiles }.
+ *
+ * @param {string} releaseBranch
+ * @returns {{ sourceFiles: string[], testFiles: string[] }}
+ */
+BranchDiff.prototype.getLocalChanges = function (releaseBranch) {
+  var self = this;
+  return this.getChangedFilesFromRelease(releaseBranch).then(function (releaseFiles) {
+    var stagedFiles = self.getStagedFiles();
+    console.log({
+      releaseFiles: releaseFiles,
+      stagedFiles: stagedFiles
+    });
+    // deduplicate
+    var seen = {};
+    var merged = [];
+    var all = releaseFiles.concat(stagedFiles);
+    for (var i = 0; i < all.length; i++) {
+      if (!seen[all[i]]) {
+        seen[all[i]] = true;
+        merged.push(all[i]);
+      }
     }
-    return !this._testPattern.test(filePath);
-  }
-  _isTestFile(filePath) {
-    return this._testPattern.test(filePath);
+    return self._categorizeFiles(merged);
+  });
+};
+
+/**
+ * CI mode — release branch diff only.
+ * Returns categorized { sourceFiles, testFiles }.
+ *
+ * @param {string} releaseBranch
+ * @returns {{ sourceFiles: string[], testFiles: string[] }}
+ */
+BranchDiff.prototype.getCIChanges = function (releaseBranch) {
+  var self = this;
+  return this.getChangedFilesFromRelease(releaseBranch).then(function (releaseFiles) {
+    return self._categorizeFiles(releaseFiles);
+  });
+};
+
+/* ------------------------------------------------------------------ */
+/*  Categorization helpers                                              */
+/* ------------------------------------------------------------------ */
+
+BranchDiff.prototype._isSourceFile = function (filePath) {
+  var ext = path.extname(filePath);
+  if (this._sourceExtensions.indexOf(ext) === -1) {
+    return false;
   }
-  _categorizeFiles(files) {
-    const sourceFiles = [];
-    const testFiles = [];
-    for (const file of files) {
-      if (this._isTestFile(file)) {
-        testFiles.push(file);
-      } else if (this._isSourceFile(file)) {
-        sourceFiles.push(file);
-      }
+  return !this._testPattern.test(filePath);
+};
+BranchDiff.prototype._isTestFile = function (filePath) {
+  return this._testPattern.test(filePath);
+};
+BranchDiff.prototype._categorizeFiles = function (files) {
+  var sourceFiles = [];
+  var testFiles = [];
+  for (var i = 0; i < files.length; i++) {
+    var file = files[i];
+    if (this._isTestFile(file)) {
+      testFiles.push(file);
+    } else if (this._isSourceFile(file)) {
+      sourceFiles.push(file);
     }
-    return {
-      sourceFiles,
-      testFiles
-    };
   }
-}
+  return {
+    sourceFiles: sourceFiles,
+    testFiles: testFiles
+  };
+};
 module.exports = BranchDiff;