@docupace/pipeline 1.0.46 → 1.0.47-monorepo.0

package/src/changeset/create.js

@@ -0,0 +1,205 @@
+import OpenAI from 'openai';
+import z from 'zod';
+import { zodResponseFormat } from 'openai/helpers/zod';
+import fs from 'fs';
+import path from 'path';
+import inquirer from 'inquirer';
+import { getMainPackage, getPackage, findJiraTicketId } from './util.js';
+import { getPackageNames } from './package-util.js';
+import { execSync } from 'child_process';
+
+async function createChangesetDirectory() {
+  try {
+    // Use path.join to build a safe path to `.changeset`
+    const targetDir = path.join(process.cwd(), '.changeset');
+
+    // Create the directory recursively if it doesn't exist
+    await fs.promises.mkdir(targetDir, { recursive: true });
+  } catch (error) {
+    console.error('Error creating .changeset directory:', error);
+  }
+}
+
+/**
+ * Gets the current git branch name
+ */
+async function getCurrentBranch() {
+  try {
+    const branchName = execSync('git branch --show-current', {
+      encoding: 'utf8',
+      shell: true,
+    }).trim();
+    console.log(`Current branch: ${branchName}`);
+    return branchName;
+  } catch (error) {
+    console.error('Error getting current branch:', error.message);
+    throw error;
+  }
+}
+/**
+ * Extracts a Jira ticket ID from a branch name
+ */
+function extractJiraTicketId(branchName) {
+  const jiraTicketId = findJiraTicketId(branchName);
+  if (!jiraTicketId) {
+    throw new Error('No Jira ticket found in the branch name.');
+  }
+  return jiraTicketId;
+}
+
+/**
+ * Fetches Jira ticket data from Jira API
+ */
+async function fetchJiraTicketData(jiraTicketId) {
+  const jiraBaseUrl = 'https://docupacellc.atlassian.net';
+  const jiraEmail = process.env.JIRA_API_EMAIL;
+  const jiraApiKey = process.env.JIRA_API_KEY;
+  const jiraFullApiKey = `${jiraEmail}:${jiraApiKey}`;
+  const jiraUrl = `${jiraBaseUrl}/rest/api/2/issue/${jiraTicketId}`;
+
+  const jiraResponse = await fetch(jiraUrl, {
+    headers: {
+      Authorization: `Basic ${Buffer.from(jiraFullApiKey).toString('base64')}`,
+      'Content-Type': 'application/json',
+    },
+  });
+
+  if (!jiraResponse.ok) {
+    throw new Error(
+      `Failed to fetch Jira ticket ${jiraTicketId}. Status: ${jiraResponse.status}, Ticket URL: ${jiraUrl}`,
+    );
+  }
+
+  return await jiraResponse.json();
+}
+
+/**
+ * Generates release notes using OpenAI
+ */
+async function generateReleaseNotes(jiraTicketData) {
+  const openaiClient = new OpenAI({
+    apiKey: process.env['OPENAI_API_KEY'],
+  });
+
+  const ChangeRequestSchema = z.object({
+    change_type: z.enum(['patch', 'minor']),
+    summary: z.string(),
+    jira_ticket_id: z.string(),
+  });
+
+  const openAiResponse = await openaiClient.chat.completions.create({
+    model: 'gpt-4o-mini',
+    messages: [
+      {
+        role: 'system',
+        content: `Process JSON from a Jira ticket to generate simple maximum 2 sentence release note for the ticket and determine the change type for bug it should be a patch for new feature it should be a minor change`,
+      },
+      {
+        role: 'user',
+        content: JSON.stringify(jiraTicketData),
+      },
+    ],
+    response_format: zodResponseFormat(ChangeRequestSchema, 'changeset_schema'),
+    temperature: 0,
+  });
+
+  const assistantResponse = openAiResponse.choices[0].message.content;
+  return JSON.parse(assistantResponse);
+}
+
+/**
+ * Writes the changeset file
+ */
+async function writeChangesetFile(packages, jiraTicketId, changeType, summary) {
+  // Generate the YAML frontmatter for multiple packages
+  const packageEntries = packages
+    .map((pkg) => `'${pkg.name}': ${changeType}`)
+    .join('\n');
+
+  const changesetContent = `---
+${packageEntries}
+---
+
+${summary} [${jiraTicketId}]
+`;
+  const changesetFile = `./.changeset/${jiraTicketId}.md`;
+
+  await createChangesetDirectory();
+  await fs.promises.writeFile(changesetFile, changesetContent);
+  console.log(`Created changeset file at ${changesetFile}`);
+}
+
+/**
+ * Main function to create a changeset
+ */
+
+export async function createChangeset() {
+  const packages = getPackageNames();
+
+  if (packages.length > 1) {
+    const allPackages = packages;
+    const response = await inquirer.prompt([
+      {
+        type: 'checkbox',
+        name: 'packages',
+        message: 'Which packages do you want to generate changesets for?',
+        choices: allPackages.map((appPackage) => ({
+          name: appPackage.name,
+          value: appPackage.name,
+        })),
+        validate: (input) => {
+          if (input.length === 0) {
+            return 'Please select at least one package.';
+          }
+          return true;
+        },
+      },
+    ]);
+
+    const selectedPackages = allPackages.filter((appPackage) =>
+      response.packages.includes(appPackage.name),
+    );
+
+    // Get package contents for all selected packages
+    const selectedPackageContents = await Promise.all(
+      selectedPackages.map(async (selectedPackage) => {
+        return await getPackage(selectedPackage.path);
+      }),
+    );
+
+    await createChangesetForPackage(selectedPackageContents);
+  } else {
+    const mainPackage = await getMainPackage();
+    await createChangesetForPackage([mainPackage]);
+  }
+}
+
+export async function createChangesetForPackage(packages) {
+  try {
+    // Step 1: Get the current branch name
+    const branchName = await getCurrentBranch();
+
+    // Step 2: Extract Jira ticket number
+    const jiraTicketId = extractJiraTicketId(branchName);
+
+    // Step 3: Fetch Jira ticket data
+    const jiraTicketData = await fetchJiraTicketData(jiraTicketId);
+    const jiraSummary = jiraTicketData.fields.summary;
+    console.log(
+      `Generating release notes for ${jiraTicketId} - ${jiraSummary}`,
+    );
+
+    // Step 4: Generate release notes using OpenAI
+    const { change_type, summary } = await generateReleaseNotes(jiraTicketData);
+    console.log(`Change type: ${change_type}`);
+    console.log(`Release note: ${summary}`);
+
+    // Step 5: Create a changeset .md file for all packages
+    await writeChangesetFile(packages, jiraTicketId, change_type, summary);
+
+    console.log('Changeset created successfully!');
+  } catch (err) {
+    console.error(`Error: ${err.message}`);
+    process.exit(1);
+  }
+}

package/src/changeset/package-util.js

@@ -0,0 +1,86 @@
+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 }]
+          : [];
+      } 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,
+            });
+          }
+        } 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,44 @@
 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() {
+  if (isMonoRepo()) {
+    await setGitInfo();
+    const destBranch = process.env.BITBUCKET_PR_DESTINATION_BRANCH;
+    await $`git fetch origin ${destBranch}:${destBranch}`;
+    await versionStatus(destBranch);
+    /*const changedPackages = await getChangedPackages();
+    const releaseNames = releases.map((release) => release.name);
+    const changedPackageNames = changedPackages.map(
+      (changedPackage) => changedPackage.name,
+    );
+
+    if (!areArraysEqualIgnoringOrder(releaseNames, changedPackageNames)) {
+      throw new Error(
+        'Changesets must be created for all packages created and for those that have those changed as dependencies',
+      );
+    }*/
+  } else {
+    await validateChangesetPath(path.resolve(process.cwd(), CHANGESET_DIR));
+  }
+}
+
+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,94 @@
+import { setGitInfo } from '../next/util.js';
+import { $ } from 'zx';
+import fs from 'fs';
+import { updateComponentVersion } from '../next/jira.js';
+import { findJiraTicketId } from './util.js';
+
+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 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...');
+  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`;
+  }
+
+  try {
+    const releases = await versionStatus();
+
+    const { stdout } = await $`git symbolic-ref refs/remotes/origin/HEAD`;
+    const defaultBranch = stdout.trim().replace('refs/remotes/origin/', '');
+
+    await $`git fetch origin ${defaultBranch}`;
+
+    await $`pnpm changeset version`;
+
+    return releases;
+  } catch {
+    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/next/cli.js

@@ -7,25 +7,24 @@ import { publish } from './publish.js';
 import {
   deployAppWithTag,
   deployFromSite,
+  deployTemplate,
   getDefaultDeploySite,
   getDeployTag,
 } from './deploy.js';
-import { deployTemplate } from './deploy.js';
-import { copy } from './copy.js';
+import { copy, copy2 } from './copy.js';
 import { vaultAddSiteData } from './vault.js';
 import { addApacheSite } from './apache.js';
 import { haproxySync } from './haproxy.js';
 import { connectClone } from './connect.js';
 import dotenv from 'dotenv';
+import { $ } from 'zx';
+import { deployConnect, deployCore } from './jenkins.js';
+import { runPipeline } from './pipline.js';
 
 dotenv.config({ path: ['.env.pipeline.local', 'config/.env.pipeline.local'] });
 
 const program = new Command();
 
-import { $ } from 'zx';
-import { deployConnect, deployCore } from './jenkins.js';
-import { runPipeline } from './pipline.js';
-
 const GIT_SHA = (await $`git log --pretty=format:'%h' -n 1`).stdout.trim();
 
 program
@@ -106,10 +105,10 @@ program
   });
 
 program
-  .command('deploy-template')
+  .command('deploy-template <tagPrefix>')
   .description('Deploy an application for a specific site')
-  .action(async () => {
-    const deployTag = await getDeployTag();
+  .action(async (tagPrefix) => {
+    const deployTag = await getDeployTag(tagPrefix);
     const { env, site } = await getDefaultDeploySite(deployTag);
     await deployTemplate(env, site, deployTag);
   });
@@ -132,6 +131,16 @@ program
     await deployAppWithTag(application, env, site, deployTag);
   });
 
+program
+  .command('deploy-mono-app <tag> <application>')
+  .description('Deploy an application for a specific site')
+  .action(async (tag, application) => {
+    const deployTag = await getDeployTag(tag);
+    const version = 'v' + deployTag.split('@')[1];
+    const { env, site } = await getDefaultDeploySite(version);
+    await deployAppWithTag(application, env, site, version);
+  });
+
 program
   .command('deploy-core <env> <site>')
   .description('Deploy Core')
@@ -167,13 +176,14 @@ program
 program
   .command('copy')
   .description('Copy a Docker image between registries')
-  .requiredOption('-a, --application <application>', 'Application name')
+  .requiredOption('-r, --repository <repository>', 'Repostory name')
   .requiredOption('-f, --from-env <fromEnv>', 'Source environment')
   .requiredOption('-t, --to-env <toEnv>', 'Target environment')
   .requiredOption('-g, --tag <tag>', 'Image tag')
+  .requiredOption('-a, --application <application>', 'Application name')
   .action(async (options) => {
-    const { application, fromEnv, toEnv, tag } = options;
-    await copy(application, fromEnv, toEnv, tag);
+    const { repository, fromEnv, toEnv, tag, application } = options;
+    await copy2(repository, fromEnv, toEnv, tag, application);
   });
 
 program

package/src/next/config.js

@@ -1,5 +1,9 @@
+import semver from 'semver';
+
 export const environments = ['dev', 'qa', 'uat', 'stage', 'prod'];
 
+const UI_MONO_VERSION = '1.4.0-alpha.0';
+
 export const environmentConfig = {
   dev: {
     newUrl: (site) => `https://${site}.dev.dpai.tech`,
@@ -36,15 +40,47 @@ export const environmentConfig = {
 export const appInfo = {
   'graphql-server': {
     repositoryName: 'docupace-graphql-server',
+    imageName: 'docupace-graphql-server',
     deployAttributes: [
       'image.tag',
       'graphqlServer.siteConfigRemoteBranch',
       'graphqlServer.standardConfigRemoteBranch',
     ],
   },
+  cc: {
+    repositoryName: 'docupace-ui-main',
+    imageName: 'cc-ui-app',
+    deployAttributes: ['image.tag'],
+    getAppRevision: (config) => {
+      const version = config.image.tag.slice(1);
+      return 'cc-ui-app@' + version;
+    },
+  },
   ui: {
     repositoryName: 'docupace-ui-main',
+    imageName: 'enterprise-ui-app',
     deployAttributes: ['image.tag'],
+    getAppRevision: (config) => {
+      const tag = config.image.tag;
+      const version = tag.startsWith('v') ? tag.slice(1) : tag;
+      if (semver.gt(version, UI_MONO_VERSION)) {
+        return 'enterprise-ui-app@' + version;
+      } else {
+        return tag;
+      }
+    },
+    updateConfigFunction: (config) => {
+      if (config.image.repository.endsWith('/docupace-ui-main')) {
+        const tag = config.image.tag;
+        const version = tag.startsWith('v') ? tag.slice(1) : tag;
+        if (semver.gt(version, UI_MONO_VERSION)) {
+          const parts = config.image.repository.split('/');
+          parts[2] = 'enterprise-ui-app';
+          config.image.repository = parts.join('/');
+        }
+      }
+      return config;
+    },
   },
 };
 

package/src/next/copy.js

@@ -11,7 +11,7 @@ export async function copy(application, fromEnv, toEnv, tag) {
   const repositoryName = appInfo[application].repositoryName;
   const fromRegistry = `${jfRegistryUrl}/${repositoryName}-${fromEnv}-docker-local`;
   const toRegistry = `${jfRegistryUrl}/${repositoryName}-${toEnv}-docker-local`;
-  const imageName = `${repositoryName}:${tag}`;
+  const imageName = `${appInfo[application].imageName}:${tag}`;
   const fromFullImageName = `${fromRegistry}/${imageName}`;
   const toFullImageName = `${toRegistry}/${imageName}`;
 
@@ -29,14 +29,20 @@ export async function copy(application, fromEnv, toEnv, tag) {
   await $`docker push ${toFullImageName}`;
 }
 
-export async function copy2(repositoryName, fromEnv, toEnv, tag) {
+export async function copy2(
+  repositoryName,
+  fromEnv,
+  toEnv,
+  tag,
+  applicationName,
+) {
   console.log(
     `Copying repository ${repositoryName} from ${fromEnv} to ${toEnv} for tag ${tag}`,
   );
   const envInfo = getEnvInfo();
   const fromRegistry = `${jfRegistryUrl}/${repositoryName}-${fromEnv}-docker-local`;
   const toRegistry = `${jfRegistryUrl}/${repositoryName}-${toEnv}-docker-local`;
-  const imageName = `${repositoryName}:${tag}`;
+  const imageName = `${applicationName ?? repositoryName}:${tag}`;
   const fromFullImageName = `${fromRegistry}/${imageName}`;
   const toFullImageName = `${toRegistry}/${imageName}`;