@docupace/pipeline 1.0.7-beta.2 → 1.0.8-6.xray

package/src/changeset/package-util.js

@@ -0,0 +1,87 @@
+import fs from 'fs';
+import path from 'path';
+
+export function getPackageNames(rootPath = '.') {
+  const appsDir = path.join(rootPath, 'apps');
+  const packagesDir = path.join(rootPath, 'packages');
+  const rootPackageJson = path.join(rootPath, 'package.json');
+
+  // Check if this is a monorepo (has apps and/or packages directories)
+  const hasAppsDir =
+    fs.existsSync(appsDir) && fs.statSync(appsDir).isDirectory();
+  const hasPackagesDir =
+    fs.existsSync(packagesDir) && fs.statSync(packagesDir).isDirectory();
+
+  if (hasAppsDir || hasPackagesDir) {
+    // This is a monorepo
+    const packages = [];
+
+    // Get packages from apps directory
+    if (hasAppsDir) {
+      const appsPackages = getPackagesFromDirectory(appsDir);
+      packages.push(...appsPackages);
+    }
+
+    // Get packages from packages directory
+    if (hasPackagesDir) {
+      const packagesPackages = getPackagesFromDirectory(packagesDir);
+      packages.push(...packagesPackages);
+    }
+
+    return packages;
+  } else {
+    // This is not a monorepo, return single package
+    if (fs.existsSync(rootPackageJson)) {
+      try {
+        const packageJson = JSON.parse(
+          fs.readFileSync(rootPackageJson, 'utf8'),
+        );
+        return packageJson.name
+          ? [{ name: packageJson.name, path: rootPath, content: packageJson }]
+          : [];
+      } catch (error) {
+        console.error('Error reading root package.json:', error);
+        return [];
+      }
+    }
+    return [];
+  }
+}
+
+function getPackagesFromDirectory(dirPath) {
+  const packages = [];
+
+  try {
+    const items = fs.readdirSync(dirPath);
+
+    for (const item of items) {
+      const itemPath = path.join(dirPath, item);
+      const packageJsonPath = path.join(itemPath, 'package.json');
+
+      // Check if item is a directory and has package.json
+      if (
+        fs.statSync(itemPath).isDirectory() &&
+        fs.existsSync(packageJsonPath)
+      ) {
+        try {
+          const packageJson = JSON.parse(
+            fs.readFileSync(packageJsonPath, 'utf8'),
+          );
+          if (packageJson.name) {
+            packages.push({
+              name: packageJson.name,
+              path: itemPath,
+              content: packageJson,
+            });
+          }
+        } catch (error) {
+          console.error(`Error reading package.json in ${itemPath}:`, error);
+        }
+      }
+    }
+  } catch (error) {
+    console.error(`Error reading directory ${dirPath}:`, error);
+  }
+
+  return packages;
+}

package/src/changeset/util.js

@@ -0,0 +1,43 @@
+import path from 'path';
+import fs from 'fs';
+
+async function fileExists(filePath) {
+  try {
+    await fs.promises.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+export async function getMainPackage() {
+  const mainModulePath = process.cwd();
+  return getPackage(mainModulePath);
+}
+
+export async function getPackage(mainModulePath) {
+  if (mainModulePath) {
+    const packageJsonPath = path.join(mainModulePath, 'package.json');
+    if (await fileExists(packageJsonPath)) {
+      const fileContent = await fs.promises.readFile(packageJsonPath, 'utf-8');
+      const packageJson = JSON.parse(fileContent);
+      return packageJson;
+    }
+  }
+  throw new Error('Main package.json not found');
+}
+
+/**
+ * Locates and extracts a JIRA Ticket ID from a given string.
+ * <p>
+ * The JIRA Ticket ID is expected to follow the pattern of uppercase letters (at least two) followed by a hyphen and digits (e.g., DC-1234, INFP-9).
+ * @param str the string to search for a JIRA ticket ID
+ * @returns {JIRA-TicketID|null}
+ */
+export function findJiraTicketId(str) {
+  if (!str) {
+    return null;
+  }
+  const regex = /([A-Z]{2,}-\d+)/;
+  const matches = str.match(regex);
+  return matches ? matches[0] : null;
+}

package/src/changeset/validate.js

@@ -1,7 +1,51 @@
 import fs from 'fs';
 import path from 'path';
+import { $ } from 'zx';
 
-export async function validateChangesets(directoryPath) {
+import { isMonoRepo, setGitInfo } from '../next/util.js';
+import { versionStatus } from './version.js';
+
+const CHANGESET_DIR = '.changeset';
+
+function areArraysEqualIgnoringOrder(arr1, arr2) {
+  if (arr1.length !== arr2.length) return false;
+
+  const sortedA = [...arr1].sort();
+  const sortedB = [...arr2].sort();
+
+  return sortedA.every((element, index) => element === sortedB[index]);
+}
+
+export async function validateChangesets() {
+  await setGitInfo();
+  const destBranch = process.env.BITBUCKET_PR_DESTINATION_BRANCH;
+  await $`git fetch origin ${destBranch}:${destBranch}`;
+  let releases;
+
+  try {
+    console.log('🔍 Validating changesets...');
+    releases = await versionStatus(destBranch);
+  } catch (e) {
+    console.error(
+      '❌ No changeset found. Please add a changeset to this PR. Please see more information at https://docupacellc.atlassian.net/wiki/spaces/PM/pages/1350893571/Creating+changesets+for+Docupace+Next',
+      e,
+    );
+    process.exit(-1);
+  }
+
+  if (!['master', 'main'].includes(destBranch)) {
+    if (releases.some((item) => item.type !== 'patch')) {
+      console.error(
+        '❌ A changeset must be a patch for change to a release branch',
+      );
+      process.exit(-1);
+    }
+  }
+
+  console.log('✅ Changeset validation passed.');
+}
+
+export async function validateChangesetPath(directoryPath) {
   try {
     // Step 1: Read the directory for md files excluding README.md
     const allFiles = fs.readdirSync(directoryPath);

package/src/changeset/version.js

@@ -0,0 +1,102 @@
+import { setGitInfo } from '../next/util.js';
+import { $ } from 'zx';
+import fs from 'fs';
+import { updateComponentVersion } from '../next/jira.js';
+import { findJiraTicketId } from './util.js';
+import { revertBaseBranch, updateBaseBranch } from './changeset-config.js';
+import semver from 'semver';
+
+const changeSetPackage = `{
+  "name": "changeset-package",
+  "version": "1.0.0",
+  "description": "",
+  "scripts": {
+  },
+  "type": "module",
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {},
+  "devDependencies": {
+    "@changesets/cli": "^2.27.10"
+  }
+}
+`;
+
+export function toShortVersion(version) {
+  const parsed = semver.parse(version);
+  if (!parsed) return null;
+  return `${parsed.major}.${parsed.minor}`;
+}
+
+export async function versionStatus(sinceBranch) {
+  const outputPath = './changeset-output.json';
+
+  if (sinceBranch) {
+    await $`pnpm changeset status --output=${outputPath} --since=${sinceBranch}`;
+  } else {
+    await $`pnpm changeset status --output=${outputPath}`;
+  }
+
+  // Read the file and parse JSON
+  const jsonOutput = JSON.parse(await fs.promises.readFile(outputPath, 'utf8'));
+
+  await fs.promises.rm(outputPath);
+  return jsonOutput.releases;
+}
+
+export async function versionCommand(closeVersion = false) {
+  console.log('📦 Running Changeset versioning...');
+  if (!process.env.IS_DEV) {
+    await setGitInfo();
+    await $`mv package.json package.json.bak`;
+    await $`mv pnpm-lock.yaml pnpm-lock.yaml.bak`;
+    await fs.promises.writeFile('package.json', changeSetPackage);
+    await $`pnpm install`;
+    await $`rm package.json pnpm-lock.yaml`;
+    await $`mv package.json.bak package.json`;
+    await $`mv pnpm-lock.yaml.bak pnpm-lock.yaml`;
+  }
+  if (closeVersion) {
+    await $`pnpm changeset pre exit`;
+  }
+
+  let originalBaseBranch;
+  try {
+    originalBaseBranch = updateBaseBranch();
+    const releases = await versionStatus();
+    revertBaseBranch(originalBaseBranch);
+    await $`pnpm changeset version`;
+
+    return releases;
+  } catch {
+    revertBaseBranch(originalBaseBranch);
+    return [];
+  }
+}
+
+export async function updateJiraWithVersion(releases) {
+  const lastCommit = (await $`git log -1 --pretty=%B`).stdout.trim();
+  console.log(`Last commit '${lastCommit}' being processed to get Jira ticket`);
+
+  const jiraTicketId = findJiraTicketId(lastCommit);
+
+  // If we have all the necessary data, update the component version in Jira
+  if (jiraTicketId) {
+    for (const release of releases) {
+      try {
+        await updateComponentVersion(
+          jiraTicketId,
+          release.name,
+          release.newVersion,
+        );
+      } catch (error) {
+        console.error(
+          `Failed to update Jira component version: ${error.message}`,
+        );
+      }
+    }
+  }
+
+  console.log('✅ Changeset versioning complete.');
+}

package/src/jenkins/setParams.groovy

@@ -1,6 +1,5 @@
 import groovy.json.JsonSlurper
-
-import hudson.model.*;
+import hudson.model.*
 
 def build = Thread.currentThread().executable
 def params = build.getEnvironment(listener)

package/src/jfrog/xray-scan.yaml

@@ -0,0 +1,29 @@
+definitions:
+  steps:
+    - step: &xray
+        name: JFrog Xray Dependency Scan (TABLE report only)
+        runs-on:
+          - self.hosted
+          - linux.shell
+          - onprem
+        script:
+          - curl -fL https://install-cli.jfrog.io | sh
+          - jf --version
+          - jf config add scan1 --url=$JFROG_XRAY_URL --user=$JFROG_XRAY_USER --access-token=$JFROG_XRAY_PASSWORD
+          - jf c show
+          - mkdir -p xray-report
+          - jf audit . --format=table >  xray-report/xray-audit.txt
+          - jf config remove scan1
+        artifacts:
+          - xray-report/xray-audit.txt
+    - step: &version-step
+        runs-on:
+          - self.hosted
+          - linux.shell
+          - onprem
+        name: Version, Tag
+        caches:
+          - gradle
+        script:
+          - npm config set //registry.npmjs.org/:_authToken $DOCUPACE_NPM_TOKEN
+          - eval $PIPELINE_CMD_VERSION_CHANGESET

package/src/lib/merge-driver.js

@@ -0,0 +1,204 @@
+#!/usr/bin/env node
+
+import fs from 'fs';
+import { execSync } from 'child_process';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+// Get __dirname equivalent in ESM
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+/**
+ * Default merge logic function - can be overridden
+ * @param {string} headContent - The content from HEAD (current branch)
+ * @param {string} branchContent - The content from the incoming branch
+ * @returns {string} - The merged content
+ * @throws {Error} - If the conflict cannot be automatically merged
+ */
+export function defaultMergeLogic(headContent, branchContent) {
+  // Default implementation - throws error
+  // Users should provide their own implementation
+  throw new Error(
+    'No merge logic provided - please pass a custom merge function',
+  );
+}
+
+/**
+ * Main merge driver function
+ * @param {string} filePath - Path to the file with conflicts
+ * @param {Function} customMergeLogic - Custom merge function (optional)
+ * @returns {Promise<{success: boolean, totalConflicts: number, resolvedConflicts: number, hasUnresolvedConflicts: boolean}>}
+ */
+export async function mergeDriver(filePath, customMergeLogic = null) {
+  // Use provided merge logic or fall back to default
+  const mergeLogic = customMergeLogic || defaultMergeLogic;
+
+  if (!filePath) {
+    throw new Error('File path is required');
+  }
+
+  // Check if file exists
+  if (!fs.existsSync(filePath)) {
+    throw new Error(`File not found: ${filePath}`);
+  }
+
+  console.log(`Processing conflicts in: ${filePath}`);
+
+  // Read the file content
+  let fileContent;
+  try {
+    fileContent = fs.readFileSync(filePath, 'utf8');
+  } catch (error) {
+    throw new Error(`Error reading file: ${error.message}`);
+  }
+
+  // Split content into lines for processing
+  const lines = fileContent.split('\n');
+  const resultLines = [];
+
+  // Track merge state
+  let hasUnresolvedConflicts = false;
+  let totalConflicts = 0;
+  let resolvedConflicts = 0;
+
+  // State variables for parsing
+  let inConflict = false;
+  let headLines = [];
+  let branchLines = [];
+  let currentSection = null; // 'head' or 'branch'
+
+  // Process each line
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+
+    if (line.startsWith('<<<<<<<')) {
+      // Start of conflict marker
+      inConflict = true;
+      currentSection = 'head';
+      headLines = [];
+      branchLines = [];
+      totalConflicts++;
+    } else if (inConflict && line.startsWith('=======')) {
+      // Middle of conflict - switch from HEAD to branch
+      currentSection = 'branch';
+    } else if (inConflict && line.startsWith('>>>>>>>')) {
+      // End of conflict marker - attempt to merge
+      const headContent = headLines.join('\n');
+      const branchContent = branchLines.join('\n');
+
+      try {
+        // Call custom merge logic
+        const mergedContent = mergeLogic(headContent, branchContent);
+
+        // Add merged content to result
+        if (mergedContent !== null && mergedContent !== undefined) {
+          resultLines.push(mergedContent);
+          resolvedConflicts++;
+          console.log(`✓ Resolved conflict #${totalConflicts}`);
+        }
+      } catch (error) {
+        // Cannot merge this conflict - keep original conflict markers
+        hasUnresolvedConflicts = true;
+
+        console.log(
+          `✗ Could not resolve conflict #${totalConflicts}: ${error.message}`,
+        );
+
+        // Preserve the original conflict
+        resultLines.push(`<<<<<<< HEAD`);
+        resultLines.push(headContent);
+        resultLines.push('=======');
+        resultLines.push(branchContent);
+        resultLines.push(`>>>>>>> branch`);
+      }
+
+      // Reset conflict state
+      inConflict = false;
+      currentSection = null;
+      headLines = [];
+      branchLines = [];
+    } else if (inConflict) {
+      // Inside conflict - collect lines
+      if (currentSection === 'head') {
+        headLines.push(line);
+      } else if (currentSection === 'branch') {
+        branchLines.push(line);
+      }
+    } else {
+      // Normal line outside of conflict
+      resultLines.push(line);
+    }
+  }
+
+  // Write the result back to the file
+  const resultContent = resultLines.join('\n');
+  try {
+    fs.writeFileSync(filePath, resultContent, 'utf8');
+    console.log(`\nFile updated: ${filePath}`);
+  } catch (error) {
+    throw new Error(`Error writing file: ${error.message}`);
+  }
+
+  // Summary
+  console.log('\n--- Merge Summary ---');
+  console.log(`Total conflicts found: ${totalConflicts}`);
+  console.log(`Conflicts resolved: ${resolvedConflicts}`);
+  console.log(`Conflicts remaining: ${totalConflicts - resolvedConflicts}`);
+
+  // If all conflicts were resolved, stage the file
+  if (!hasUnresolvedConflicts && totalConflicts > 0) {
+    try {
+      execSync(`git add "${filePath}"`, { stdio: 'inherit' });
+      console.log(
+        `\n✓ All conflicts resolved! File has been staged with 'git add'.`,
+      );
+    } catch (error) {
+      console.error(`\nWarning: Could not stage file: ${error.message}`);
+      console.log('You may need to run "git add" manually.');
+    }
+  } else if (hasUnresolvedConflicts) {
+    console.log(`\n⚠ Some conflicts could not be resolved automatically.`);
+    console.log('Please review and resolve the remaining conflicts manually.');
+  } else if (totalConflicts === 0) {
+    console.log('\nNo conflicts found in the file.');
+  }
+
+  // Return result object for programmatic use
+  return {
+    success: !hasUnresolvedConflicts,
+    totalConflicts,
+    resolvedConflicts,
+    hasUnresolvedConflicts,
+    filePath,
+  };
+}
+
+/**
+ * Process multiple files with the same merge logic
+ * @param {string[]} filePaths - Array of file paths to process
+ * @param {Function} customMergeLogic - Custom merge function
+ * @returns {Promise<Array>} - Array of results for each file
+ */
+export async function mergeMultipleFiles(filePaths, customMergeLogic) {
+  const results = [];
+
+  for (const filePath of filePaths) {
+    try {
+      const result = await mergeDriver(filePath, customMergeLogic);
+      results.push(result);
+    } catch (error) {
+      console.error(`Error processing ${filePath}: ${error.message}`);
+      results.push({
+        success: false,
+        error: error.message,
+        filePath,
+      });
+    }
+  }
+
+  return results;
+}
+
+// Default export for convenience
+export default mergeDriver;