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

package/src/next/deploy.js

@@ -1,13 +1,15 @@
+import axios from 'axios';
 import fs from 'fs';
-import path from 'path';
 import yaml from 'js-yaml';
-import { $ } from 'zx';
 import lodash from 'lodash';
+import path from 'path';
+import semver from 'semver';
+import { $ } from 'zx';
 import { appInfo, environmentConfig, getRepUrl } from './config.js';
-import { copy } from './copy.js';
-import axios from 'axios';
-import { runPipeline } from './pipline.js';
-import { deployCore } from './jenkins.js';
+import { copy2 } from './copy.js';
+import { gitDescribeToSemver } from './git-to-semver.js';
+import { deployConnect, deployCore } from './jenkins.js';
+import { makeJiraRequest } from './jira.js';
 
 /**
  * Clone the repository, read the YAML file, and return the parsed data and file paths.
@@ -22,11 +24,130 @@ function getRepoLocalPath(env) {
   return { repoPath, repoName };
 }
 
-async function cloneEnvRepository(env) {
+async function updateAndCommitConnectVersion(
+  toEnv,
+  toSite,
+  getComparedVersion,
+  connectDeployPath,
+) {
+  const connectToEnv = toEnv == 'qa' ? 'preprod' : toEnv;
+  const filePath = path.join(
+    connectDeployPath,
+    'envs',
+    connectToEnv,
+    toSite,
+    'dock.sh',
+  );
+
+  try {
+    let content = fs.readFileSync(filePath, 'utf8');
+    content = content.replace(
+      /IMAGE_VERSION=.*/,
+      `IMAGE_VERSION=git-commit-${getComparedVersion}`,
+    );
+    fs.writeFileSync(filePath, content, 'utf8');
+
+    // Git commands to stage, commit and push changes
+    await $`cd ${connectDeployPath} && git config user.email "gitops@docupace.com"`;
+
+    if (process.env.BITBUCKET_STEP_TRIGGERER_UUID) {
+      try {
+        const response = await axios.get(
+          `https://api.bitbucket.org/2.0/users/${process.env.BITBUCKET_STEP_TRIGGERER_UUID}`,
+        );
+        const triggererUsername = response.data.display_name;
+        console.log(`📌 Run triggered by: ${triggererUsername}`);
+        await $`cd ${connectDeployPath} && git config user.name ${triggererUsername}`;
+      } catch (error) {
+        console.warn('Failed to fetch Bitbucket user info:', error.message);
+      }
+    }
+
+    await $`cd ${connectDeployPath} && git add .`;
+    await $`cd ${connectDeployPath} && git commit -m "Update Connect version for ${toSite} in ${toEnv} to ${getComparedVersion}" || echo "No changes to commit"`;
+    await $`cd ${connectDeployPath} && git push`;
+
+    console.log('🧹 Cleaning up...');
+    await $`rm -rf ${connectDeployPath}`;
+    console.log('✅ Cleanup complete.');
+  } catch (error) {
+    console.error('Error updating Connect version:', error);
+    throw error;
+  }
+}
+
+async function fetchLoginFooter(env, site, isNewUrl) {
+  const url = isNewUrl
+    ? environmentConfig[env].newUrl(site)
+    : environmentConfig[env].oldUrl(site);
+  const endpoint = isNewUrl ? '/connect/loginFooter' : '_ui/loginFooter';
+  return await axios.get(`${url}${endpoint}`);
+}
+
+async function compareGetConnectSiteVersions(fromEnv, fromSite, toEnv, toSite) {
+  try {
+    let fromResponse, toResponse;
+    try {
+      fromResponse = await fetchLoginFooter(fromEnv, fromSite, true);
+    } catch {
+      fromResponse = await fetchLoginFooter(fromEnv, fromSite, false);
+    }
+
+    try {
+      toResponse = await fetchLoginFooter(toEnv, toSite, true);
+    } catch {
+      toResponse = await fetchLoginFooter(toEnv, toSite, false);
+    }
+
+    const fromMatch = fromResponse.data.match(/UI Build: ([a-f0-9]*)/);
+    const toMatch = toResponse.data.match(/UI Build: ([a-f0-9]*)/);
+
+    if (fromMatch && fromMatch[1] && toMatch && toMatch[1]) {
+      if (fromMatch[1] !== toMatch[1]) {
+        return fromMatch[1];
+      }
+    }
+    return false;
+  } catch (error) {
+    console.error('Error fetching Connect versions:', error);
+    throw error;
+  }
+}
+function getRepoLocalPathByRepoSlug(repoSlug) {
+  const repoName = `${repoSlug}`;
+  const repoPath = path.join(process.cwd(), repoName);
+  return { repoPath, repoName };
+}
+
+function cleanUpRepoPath(repoPath) {
+  // Check and handle repo directory
+  if (fs.existsSync(repoPath)) {
+    console.log(`${repoPath} directory exists. Removing it...`);
+    fs.rmSync(repoPath, {
+      recursive: true,
+      force: true,
+    });
+  }
+}
+
+export async function cloneEnvRepository(env) {
   const { repoPath, repoName } = getRepoLocalPath(env);
   const repoUrl = getRepUrl(repoName);
   console.log(`Cloning repository: ${repoName}`);
-  await $`git clone ${repoUrl}`;
+  await cleanUpRepoPath(repoPath);
+  await $`git clone --depth 1 ${repoUrl}`;
+  console.log(`Repository cloned to: ${repoPath}`);
+  return repoPath;
+}
+
+export async function cloneRepository(repoSlug) {
+  const { repoPath, repoName } = getRepoLocalPathByRepoSlug(repoSlug);
+  const repoUrl = getRepUrl(repoName);
+
+  await cleanUpRepoPath(repoPath);
+
+  console.log(`Cloning repository: ${repoName}`);
+  await $`git clone --depth 1 ${repoUrl}`;
   console.log(`Repository cloned to: ${repoPath}`);
   return repoPath;
 }
@@ -41,7 +162,24 @@ function getConfigPath(application, env, site, name) {
   return { repoPath, deployConfigFilePath };
 }
 
-async function readDeployConfig(application, env, site, name) {
+function getAppTypesFromRepo(env, site) {
+  const { repoPath } = getRepoLocalPath(env);
+  const deployConfigFilePath = path.join(repoPath, `dp/${site}`);
+  const applications = [];
+  if (fs.existsSync(deployConfigFilePath)) {
+    const files = fs.readdirSync(deployConfigFilePath);
+    files.forEach((file) => {
+      if (file.includes('.values.yaml')) {
+        const appName = file.split('.')[0];
+        applications.push(appName);
+      }
+    });
+  }
+
+  return { applications };
+}
+
+export async function readDeployConfig(application, env, site, name) {
   const { deployConfigFilePath } = getConfigPath(application, env, site, name);
 
   let deployConfig;
@@ -109,6 +247,20 @@ export async function pushDeployConfig(repoPath, commitMessage) {
 
   console.log('📌 Committing changes to the repository...');
   await $`cd ${repoPath} && git config user.email "gitops@docupace.com"`;
+
+  if (process.env.BITBUCKET_STEP_TRIGGERER_UUID) {
+    try {
+      const response = await axios.get(
+        `https://api.bitbucket.org/2.0/users/${process.env.BITBUCKET_STEP_TRIGGERER_UUID}`,
+      );
+      const triggererUsername = response.data.display_name;
+      console.log(`📌 Run triggered by: ${triggererUsername}`);
+      await $`cd ${repoPath} && git config user.name ${triggererUsername}`;
+    } catch (error) {
+      console.warn('Failed to fetch Bitbucket user info:', error.message);
+    }
+  }
+
   await $`cd ${repoPath} && git add .`;
   await $`cd ${repoPath} && git commit -m ${commitMessage}`;
   await $`cd ${repoPath} && git push`;
@@ -145,22 +297,62 @@ export async function writeAndPushDeployConfig(
  * @param {string} site - The site name.
  */
 
-async function getDeployTag() {
+export async function getDeployTag(prefix = 'v') {
   const gitTag = (
-    await $`git tag --points-at HEAD | grep '^v' | head -n 1`
+    await $`git tag --points-at HEAD | grep '^${prefix}' | head -n 1`
   ).stdout.trim();
   const deployTag = gitTag || `build-${process.env.BITBUCKET_BUILD_NUMBER}`;
   return deployTag;
 }
 
-export async function deployTemplate(site) {
-  const deployTag = await getDeployTag();
+function getDeploymentTargets(tag, config) {
+  const semverRegex = /^v?(\d+)\.(\d+)\.(\d+)(?:-([\w.\-]+))?$/;
+  const match = tag.match(semverRegex);
+
+  if (!match) {
+    throw new Error(`Invalid tag format: ${tag}`);
+  }
+
+  const [_, major, minor, patch, preRelease] = match;
+  const isAlpha = preRelease && preRelease.toLowerCase().includes('alpha');
+
+  return config
+    .filter((entry) => {
+      if (entry.version.toLowerCase() === 'alpha' && isAlpha) {
+        return true;
+      }
+
+      const [entryMajor, entryMinor] = entry.version.split('.');
+      return (
+        !isAlpha &&
+        parseInt(entryMajor) === parseInt(major) &&
+        parseInt(entryMinor) === parseInt(minor)
+      );
+    })
+    .map((entry) => ({ env: entry.env, site: entry.site }));
+}
+
+export async function getDefaultDeploySite(deployTag) {
+  const repPath = await cloneEnvRepository('dev');
+  const autoDeployConfigPath = path.resolve(repPath, 'auto-deploy.yaml');
+  const autoDeployConfig = yaml.load(
+    fs.readFileSync(autoDeployConfigPath, 'utf8'),
+  );
+  return getDeploymentTargets(deployTag, autoDeployConfig);
+}
+
+export async function deployTemplate(
+  env,
+  site,
+  deployTag,
+  templateType = 'standardConfigRemoteBranch',
+) {
   console.log(`Deploying standard template for site: ${site}`);
   console.log(`Using deployment tag: ${deployTag}`);
   const { repoPath, deployConfigFilePath, deployConfig } =
-    await cloneAndReadDeployConfig('graphql-server', 'dev', site);
+    await cloneAndReadDeployConfig('graphql-server', env, site);
 
-  deployConfig.graphqlServer.standardConfigRemoteBranch = deployTag;
+  deployConfig.graphqlServer[templateType] = deployTag;
 
   await writeAndPushDeployConfig(
     repoPath,
@@ -171,15 +363,69 @@ export async function deployTemplate(site) {
   console.log('Deployment completed successfully.');
 }
 
-export async function deploy(application, site) {
-  const deployTag = getDeployTag();
-
+export async function deployAppWithTag(application, env, site, deployTag) {
   console.log(`Deploying application: ${application} for site: ${site}`);
   console.log(`Using deployment tag: ${deployTag}`);
+  const appDetails = appInfo[application];
 
-  const { repoPath, deployConfigFilePath, deployConfig } =
-    await cloneAndReadDeployConfig(application, 'dev', site);
+  const repoPath = await cloneEnvRepository(env);
+  const { deployConfigFilePath: valuesFilePath } = getConfigPath(
+    application,
+    env,
+    site,
+    'values',
+  );
+  const { deployConfigFilePath: appFilePath } = getConfigPath(
+    application,
+    env,
+    site,
+    'app',
+  );
+
+  if (!fs.existsSync(valuesFilePath) || !fs.existsSync(appFilePath)) {
+    const missingFiles = [];
+    if (!fs.existsSync(valuesFilePath))
+      missingFiles.push(`${application}.values.yaml`);
+    if (!fs.existsSync(appFilePath))
+      missingFiles.push(`${application}.app.yaml`);
+    console.log(
+      `⚠️  Skipping deployment to ${site}: config file(s) missing: ${missingFiles.join(', ')}`,
+    );
+    console.log(
+      `   This site may not be configured for ${application} application`,
+    );
+    return;
+  }
+
+  if (env !== 'dev') {
+    await copy2(
+      appDetails.repositoryName,
+      'dev',
+      env,
+      deployTag,
+      appDetails.imageName,
+    );
+  }
+
+  const { deployConfig, deployConfigFilePath } = await readDeployConfig(
+    application,
+    env,
+    site,
+    'values',
+  );
   const updatedConfigData = setTag(deployConfig, deployTag);
+
+  const {
+    deployConfig: toDeployAppConfig,
+    deployConfigFilePath: toDeployAppConfigFilePath,
+  } = await readDeployConfig(application, env, site, 'app');
+
+  toDeployAppConfig.revision = appDetails.getAppRevision
+    ? appDetails.getAppRevision(updatedConfigData)
+    : updatedConfigData.image.tag;
+
+  writeDeployConfig(toDeployAppConfigFilePath, toDeployAppConfig);
+
   await writeAndPushDeployConfig(
     repoPath,
     deployConfigFilePath,
@@ -195,24 +441,27 @@ async function getAppInfo(coreUrl) {
   return await axios.get(url);
 }
 
-function getBranchNameFromVersion(version) {
-  const match = version.match(/(\d+\.\d+\.[^\-]+)(?:-(\d+)-g([a-f0-9]+))?/);
-
-  if (!match) {
-    throw new Error(`Invalid version format: ${version}`);
-  }
-
-  const fullVersion = match[1]; // e.g., 24.19.19, 24.20.alpha3, etc.
-  const customBranch = match[2]; // e.g., 4, 58, or 0
-  const commitHash = match[3]; // e.g., 668edef58e, 634cf6c904, etc.
-
-  // If "alpha" is in the version or customBranch is non-zero, use the commit hash
-  if (fullVersion.includes('alpha') || (customBranch && customBranch !== '0')) {
-    return commitHash;
+export function getBranchNameFromVersion(version) {
+  let parsed;
+  try {
+    const semverVersion = gitDescribeToSemver(version);
+    parsed = semver.parse(semverVersion);
+    let newVersion;
+    if (parsed.prerelease.length > 0) {
+      newVersion = parsed.build[1].slice(1);
+    } else if (parsed.build[0] != '0') {
+      console.error(`❌ This version is a custom branch. Deployment canceled.`);
+      process.exit(1);
+    } else {
+      newVersion = 'v' + parsed.version;
+    }
+    console.log(`Extracted version ${newVersion} from ${version}`);
+    return newVersion;
+  } catch {
+    console.log(`Error parsing version : ${version}`);
+    console.log('Parsed Object:');
+    console.log(parsed);
   }
-
-  // Otherwise, use the full version
-  return fullVersion;
 }
 
 async function getCoreBranchName(fromEnv, fromSite) {
@@ -236,13 +485,178 @@ async function getCoreBranchName(fromEnv, fromSite) {
   return branchName;
 }
 
+export async function deployApp(
+  application,
+  appDetails,
+  fromEnv,
+  fromSite,
+  toEnv,
+  toSite,
+) {
+  let changesMade = false;
+  console.log(`Processing application: ${application}`);
+
+  // Read the deployment configuration for the source environment and site
+  const { deployConfig: fromDeployConfig } = await readDeployConfig(
+    application,
+    fromEnv,
+    fromSite,
+    'values',
+  );
+
+  if (fromEnv !== toEnv) {
+    await copy2(
+      appDetails.repositoryName,
+      fromEnv,
+      toEnv,
+      fromDeployConfig.image.tag,
+      appDetails.imageName,
+    );
+  }
+
+  // Read the deployment configuration for the target environment and site
+  const {
+    deployConfig: toDeployConfig,
+    deployConfigFilePath: toDeployConfigFilePath,
+  } = await readDeployConfig(application, toEnv, toSite, 'values');
+
+  // Update target configuration using attributes specified in appInfo
+  for (const attribute of appDetails.deployAttributes) {
+    const sourceValue = lodash.get(fromDeployConfig, attribute);
+
+    if (sourceValue !== undefined) {
+      // Update the target configuration with the source value
+      lodash.set(toDeployConfig, attribute, sourceValue);
+      changesMade = true;
+    }
+  }
+
+  if (appDetails.updateConfigFunction) {
+    appDetails.updateConfigFunction(toDeployConfig);
+  }
+
+  const {
+    deployConfig: toDeployAppConfig,
+    deployConfigFilePath: toDeployAppConfigFilePath,
+  } = await readDeployConfig(application, toEnv, toSite, 'app');
+
+  toDeployAppConfig.revision = appDetails.getAppRevision
+    ? appDetails.getAppRevision(fromDeployConfig)
+    : fromDeployConfig.image.tag;
+
+  // Write updated configuration to the target YAML file
+  writeDeployConfig(toDeployConfigFilePath, toDeployConfig);
+
+  writeDeployConfig(toDeployAppConfigFilePath, toDeployAppConfig);
+  return changesMade;
+}
+
 export async function deployFromSite(
   fromEnv,
   fromSite,
   toEnv,
   toSite,
   isDeployCore,
+  isDeployConnect,
+  jiraTicket,
 ) {
+  console.log(
+    `Deploying changes from ${fromSite} in ${fromEnv} to ${toSite} in ${toEnv}${jiraTicket ? ` approved by JIRA ticket ${jiraTicket}` : ''}`,
+  );
+
+  if (toEnv === 'prod') {
+    if (!jiraTicket) {
+      console.error(
+        'The deployment to prod environment requires a JIRA ticket to be provided',
+      );
+      process.exit(1);
+    }
+
+    try {
+      const response = await makeJiraRequest(`/rest/api/2/issue/${jiraTicket}`);
+      const docupacecInstance = response.fields.customfield_10045.value;
+      const siteUrl = response.fields.customfield_10041;
+      const status = response.fields.status.name;
+      const jiraBaseUrl = response.self.split('/rest/api')[0];
+      const jiraTicketUrl = `${jiraBaseUrl}/browse/${response.key}`;
+
+      console.log(`Docupace Instance: ${docupacecInstance}`);
+      console.log(`Docupace Site URL: ${siteUrl}`);
+      console.log(`JIRA Ticket Status: ${status}`);
+      console.log(`JIRA Ticket URL: ${jiraTicketUrl}`);
+
+      const allowedStatuses = ['To Do', 'In Progress'];
+      if (!allowedStatuses.includes(status)) {
+        console.error(
+          `The JIRA ticket status must be "To Do" or "In Progress", but got "${status}"`,
+        );
+        console.error(`Please check the JIRA ticket: ${jiraTicketUrl}`);
+        process.exit(1);
+      }
+
+      if (!siteUrl.includes(toSite)) {
+        console.error(
+          `The toSite "${toSite}" must be present in the Docupace Site URL: "${siteUrl}"`,
+        );
+        console.error(`Please check the JIRA ticket: ${jiraTicketUrl}`);
+        process.exit(1);
+      }
+
+      if (docupacecInstance !== 'Production') {
+        console.error(
+          `The deployment to prod environment requires Docupace Instance to be "Production", but got "${docupacecInstance}"`,
+        );
+        console.error(`Please check the JIRA ticket: ${jiraTicketUrl}`);
+        process.exit(1);
+      }
+
+      if (fromSite !== toSite) {
+        console.error(
+          `The deployment to prod environment requires fromSite and toSite to be equal, but fromSite: "${fromSite}", toSite: "${toSite}"`,
+        );
+        console.error(`Please check the JIRA ticket: ${jiraTicketUrl}`);
+        process.exit(1);
+      }
+
+      console.log('Production deployment validations passed');
+    } catch (error) {
+      console.error(`Failed to make a Jira request: ${error.message}`);
+      process.exit(1);
+    }
+  } else if (jiraTicket) {
+    try {
+      const response = await makeJiraRequest(`/rest/api/2/issue/${jiraTicket}`);
+      const siteUrl = response.fields.customfield_10041;
+      const status = response.fields.status.name;
+      const jiraBaseUrl = response.self.split('/rest/api')[0];
+      const jiraTicketUrl = `${jiraBaseUrl}/browse/${response.key}`;
+
+      console.log(`Docupace Site URL: ${siteUrl}`);
+      console.log(`JIRA Ticket Status: ${status}`);
+      console.log(`JIRA Ticket URL: ${jiraTicketUrl}`);
+
+      const allowedStatuses = ['To Do', 'In Progress'];
+      if (!allowedStatuses.includes(status)) {
+        console.error(
+          `The JIRA ticket status must be "To Do" or "In Progress", but got "${status}"`,
+        );
+        console.error(`Please check the JIRA ticket: ${jiraTicketUrl}`);
+        process.exit(1);
+      }
+
+      if (!siteUrl.includes(toSite)) {
+        console.error(
+          `The toSite "${toSite}" must be present in the Docupace Site URL: "${siteUrl}"`,
+        );
+        console.error(`Please check the JIRA ticket: ${jiraTicketUrl}`);
+        process.exit(1);
+      }
+    } catch (error) {
+      console.error(`Failed to make a Jira request: ${error.message}`);
+      process.exit(1);
+    }
+  }
+
   if (isDeployCore === 'true') {
     const branchName = await getCoreBranchName(fromEnv, fromSite);
 
@@ -258,6 +672,30 @@ export async function deployFromSite(
     });*/
   }
 
+  if (isDeployConnect === 'true') {
+    const branch = '';
+    const getComparedVersion = await compareGetConnectSiteVersions(
+      fromEnv,
+      fromSite,
+      toEnv,
+      toSite,
+    );
+    if (getComparedVersion) {
+      console.log('Version to deploy is: ', getComparedVersion);
+      const connectDeployPath = await cloneRepository('connect-deploy');
+      // update target version set to git-commit-${getCommparedVersion}}
+      await updateAndCommitConnectVersion(
+        toEnv,
+        toSite,
+        getComparedVersion,
+        connectDeployPath,
+      );
+      // save and deploy
+      const runLiquibase = true;
+      await deployConnect(toEnv, toSite, runLiquibase, branch);
+    }
+  }
+
   // Clone repositories for source and target environments
   const fromRepoPath = await cloneEnvRepository(fromEnv);
   const toRepoPath =
@@ -265,52 +703,53 @@ export async function deployFromSite(
 
   // Initialize a flag to track changes
   let changesMade = false;
-
+  const applications = await getAppTypesFromRepo(toEnv, toSite);
+  console.log(applications);
   // Iterate over applications in appInfo
-  for (const [application, appDetails] of Object.entries(appInfo)) {
-    console.log(`Processing application: ${application}`);
 
-    // Read the deployment configuration for the source environment and site
-    const { deployConfig: fromDeployConfig } = await readDeployConfig(
-      application,
-      fromEnv,
+  let appInfoLocal = Object.fromEntries(
+    applications.applications
+      .filter((application) =>
+        Object.prototype.hasOwnProperty.call(appInfo, application),
+      )
+      .map((application) => [application, appInfo[application]]),
+  );
+
+  // let appInfoLocal = {};
+  // for (const application of applications.applications) {
+  //   if (Object.prototype.hasOwnProperty.call(appInfo, application)) {
+  //     appInfoLocal[application] = appInfo[application];
+  //   }
+  // }
+
+  if (Object.keys(appInfoLocal).length === 0) {
+    const { deployConfig: toDeployAppConfig } = await readDeployConfig(
       fromSite,
-      'values',
+      toEnv,
+      toSite,
+      'app',
     );
 
-    if (fromEnv !== toEnv) {
-      await copy(application, fromEnv, toEnv, fromDeployConfig.image.tag);
-    }
-
-    // Read the deployment configuration for the target environment and site
-    const {
-      deployConfig: toDeployConfig,
-      deployConfigFilePath: toDeployConfigFilePath,
-    } = await readDeployConfig(application, toEnv, toSite, 'values');
+    appInfoLocal[fromSite] = {
+      repositoryName: toDeployAppConfig.repo,
+      deployAttributes: ['image.tag'],
+    };
+  }
 
-    // Update target configuration using attributes specified in appInfo
-    for (const attribute of appDetails.deployAttributes) {
-      const sourceValue = lodash.get(fromDeployConfig, attribute);
+  console.log('appinfoLocal', appInfoLocal);
 
-      if (sourceValue !== undefined) {
-        // Update the target configuration with the source value
-        lodash.set(toDeployConfig, attribute, sourceValue);
-        changesMade = true;
-      }
+  for (const [application, appDetails] of Object.entries(appInfoLocal)) {
+    let cm = await deployApp(
+      application,
+      appDetails,
+      fromEnv,
+      fromSite,
+      toEnv,
+      toSite,
+    );
+    if (cm) {
+      changesMade = true;
     }
-
-    const {
-      deployConfig: toDeployAppConfig,
-      deployConfigFilePath: toDeployAppConfigFilePath,
-    } = await readDeployConfig(application, toEnv, toSite, 'app');
-
-    toDeployAppConfig.revision = fromDeployConfig.image.tag;
-
-    // Write updated configuration to the target YAML file
-    writeDeployConfig(toDeployConfigFilePath, toDeployConfig);
-
-    writeDeployConfig(toDeployAppConfigFilePath, toDeployAppConfig);
-
   }
 
   // Push all changes if any updates were made