@docupace/pipeline 1.0.5-alpha.8 → 1.0.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@docupace/pipeline",
-  "version": "1.0.5-alpha.8",
+  "version": "1.0.5",
   "description": "",
   "main": "index.js",
   "type": "module",
@@ -32,5 +32,9 @@
     "eslint-plugin-prettier": "^5.2.1",
     "globals": "^15.14.0",
     "prettier": "^3.4.2"
+  },
+  "scripts": {
+    "test-deploy-core": "dp-next-cli deploy-core-pipeline dev template",
+    "test-deploy-from-site": "dp-next-cli deploy-from-site --from-env dev --to-env dev --from-site financialdev --to-site template --deploy-core true"
   }
 }

package/src/changeset/cli.js

@@ -9,12 +9,36 @@ import { zodResponseFormat } from 'openai/helpers/zod';
 import z from 'zod';
 import dotenv from 'dotenv';
 dotenv.config({ path: ['.env.pipeline.local', 'config/.env.pipeline.local'] });
+import { exec } from 'child_process';
 
 const program = new Command();
 
 const args = process.argv;
 
-const DIR = path.resolve(process.cwd());
+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);
+  }
+}
+
+
+function run(command) {
+  return new Promise((resolve, reject) => {
+    exec(command, { shell: true }, (error, stdout, stderr) => {
+      if (error) {
+        reject(error);
+      } else {
+        resolve({ stdout, stderr });
+      }
+    });
+  });
+}
 
 async function fileExists(filePath) {
   try {
@@ -155,7 +179,8 @@ program
 
     try {
       // Step 1: Get the current branch name
-      const branchName = (await $`git branch --show-current`).stdout.trim();
+      const { stdout: branchStdout } = await run(`git branch --show-current`);
+      const branchName = branchStdout.trim();
       console.log(`Current branch: ${branchName}`);
 
       // Step 2: Extract Jira ticket number (e.g., matching JIRA-1234 pattern)
@@ -195,6 +220,7 @@ program
         `Generating release notes for ${jiraTicketId} - ${jiraSummary}`,
       );
 
+      // Step 4: Use OpenAI to generate release notes
       const openaiClient = new OpenAI({
         apiKey: process.env['OPENAI_API_KEY'],
       });
@@ -231,22 +257,23 @@ program
       console.log(`Change type: ${change_type}`);
       console.log(`Release note: ${summary}`);
 
-      // Step 5: Create a changeset using pnpm
+      // Step 5: Create a changeset .md file
       const changesetContent = `---
 "${componentName}": ${change_type}
 ---
 
 ${summary} [${jiraTicketId}]
-      `;
+`;
       const changesetFile = `./.changeset/${jiraTicketId}.md`;
 
-      await $`mkdir -p ./.changeset`;
+      await createChangesetDirectory();
       await fs.promises.writeFile(changesetFile, changesetContent);
       console.log(`Created changeset file at ${changesetFile}`);
 
       console.log('Done!');
     } catch (err) {
       console.error(`Error: ${err.message}`);
+      process.exit(1);
     }
   });
 

package/src/jenkins/setParams.groovy

@@ -0,0 +1,59 @@
+import groovy.json.JsonSlurper
+
+import hudson.model.*;
+
+def build = Thread.currentThread().executable
+def params = build.getEnvironment(listener)
+
+def site = params.get('site')
+def server = "jboss7"
+def environment = params.get('environment')
+
+def buildFile=new File("D:\\Docupace\\CustomFolders\\" + environment + "\\" + site + "\\" + server + "\\buildApp.properties")
+
+List<String> jboss7controllerResult = []
+
+def controllersReport = new File("D:\\Docupace\\controllers_report.json")
+def inputJSON = new JsonSlurper().parseText(controllersReport.text)
+def props = new Properties()
+buildFile.withInputStream { stream -> props.load(stream) }
+def webRootContext = props["web.root.context"]
+if (webRootContext == null || webRootContext =="core") webRootContext = props["docupace.config.client.id"].toLowerCase()
+
+webRootContext  = webRootContext.replaceFirst('_sso','')
+def map = inputJSON.'content'
+
+def Boolean enabled
+
+map.each {k,v ->
+    v.each{vk, vv -> if (vk == webRootContext ) {
+        enabled = false
+        if(vv.deploymentsProperty.size()>0) enabled = vv.deploymentsProperty[0].isEnabled
+        if (enabled) jboss7controllerResult.push(k)
+        else jboss7controllerResult << k
+    }
+    }
+}
+
+if (jboss7controllerResult.size()>0) {
+    if (environment == 'preprod') {
+        jboss7controllerResult.remove("dev-corjbdc10.corp.docupace.com")
+        jboss7controllerResult.remove("usdoc-s-jbdc1.corp.docupace.com")
+    }
+    if (environment == 'dev') {
+        jboss7controllerResult.remove("qa-corjbdc10.corp.docupace.com")
+        jboss7controllerResult.remove("qa-corjbdc20.corp.docupace.com")
+        jboss7controllerResult.remove("usdoc-s-jbdc2.corp.docupace.com")
+    }
+}
+
+println jboss7controllerResult[0]
+
+env.jboss7controller = jboss7controllerResult[0]
+
+def serverGroup = inputJSON.'content'."${jboss7controller}"."${webRootContext}".'serverGroup'
+
+println serverGroup
+
+params.put("serverGroup", serverGroup)
+

package/src/next/cli.js

@@ -4,7 +4,7 @@ import { Command } from 'commander';
 import { pull } from './pull.js';
 import { sonar } from './sonar.js';
 import { publish } from './publish.js';
-import { deploy, deployFromSite } from './deploy.js';
+import { deployFromSite } from './deploy.js';
 import { deployTemplate } from './deploy.js';
 import { copy } from './copy.js';
 import dotenv from 'dotenv';
@@ -15,7 +15,8 @@ const program = new Command();
 
 // GIT SHA computation
 import { $ } from 'zx';
-import {triggerJenkinsJob} from "./jenkins.js";
+import { deployCore } from './jenkins.js';
+import { runPipeline } from './pipline.js';
 const GIT_SHA = (await $`git log --pretty=format:'%h' -n 1`).stdout.trim();
 
 program
@@ -46,9 +47,10 @@ program
   .requiredOption('-t, --to-env <toEnv>', 'Target environment')
   .requiredOption('-F, --from-site <fromSite>', 'Source site')
   .requiredOption('-T, --to-site <toSite>', 'Target site')
+  .option('-c, --deploy-core <deployCore>', 'Deploy Core', 'false')
   .action(async (options) => {
-    const { fromEnv, fromSite, toEnv, toSite } = options;
-    await deployFromSite(fromEnv, fromSite, toEnv, toSite);
+    const { fromEnv, fromSite, toEnv, toSite, deployCore } = options;
+    await deployFromSite(fromEnv, fromSite, toEnv, toSite, deployCore);
   });
 
 program
@@ -61,8 +63,24 @@ program
 program
   .command('deploy-core <env> <site>')
   .description('Deploy Core')
-  .action(async (env, site) => {
-    await triggerJenkinsJob();
+  .option('-l, --liquibase <liquibase>', 'Application name', 'true')
+  .option('-b, --branch <branch>', 'Branch', 'master')
+  .action(async (env, site, options) => {
+    await deployCore(env, site, options.liquibase, options.branch);
+  });
+
+program
+  .command('deploy-core-pipeline <env> <site>')
+  .description('Deploy Core')
+  .option('-l, --liquibase <liquibase>', 'Application name', 'true')
+  .option('-b, --branch <branch>', 'Branch', 'master')
+  .action(async (env, site, options) => {
+    await runPipeline('site-deploy', 'deploy-core', 'main', {
+      ENV: env,
+      SITE: site,
+      LIQUIBASE: options.liquibase,
+      BRANCH: options.branch,
+    });
   });
 
 program

package/src/next/config.js

@@ -1,5 +1,29 @@
 export const environments = ['dev', 'qa', 'uat', 'stage', 'prod'];
 
+export const environmentConfig = {
+  dev: {
+    newUrl: (site) => `${site}.dev.dpai.tech`,
+    oldUrl: (site) => `https://www.dev.docupaceinc.com/${site}`,
+  },
+  qa: {
+    newUrl: (site) => `${site}.qa.dpai.tech`,
+    oldUrl: (site) => `https://www.preprod.docupaceinc.com/${site}`,
+  },
+  uat: {
+    newUrl: (site) => `${site}.qa.dpai.tech`,
+    oldUrl: (site) => `https://www2.paperout.com/${site}_uat`,
+  },
+  stage: {
+    newUrl: (site) => `${site}.stage.dpai.tech`,
+    oldUrl: (site) => `https://www2.paperout.com/${site}_staging`,
+  },
+
+  prod: {
+    newUrl: (site) => `${site}.dpai.tech`,
+    oldUrl: (site) => `https://www2.paperout.com/${site}`,
+  },
+};
+
 export const appInfo = {
   'graphql-server': {
     repositoryName: 'docupace-graphql-server',
@@ -35,7 +59,14 @@ export const getBitbucketInfo = () => {
   return {
     username: process.env.BITBUCKET_USERNAME,
     password: process.env.BITBUCKET_APP_PASSWORD,
+    workspace: 'dp-cloud',
   };
 };
 
+export const getRepUrl = (repoName) => {
+  const { username, password, workspace } = getBitbucketInfo();
+  const repoUrl = `https://${username}:${password}@bitbucket.org/${workspace}/${repoName}.git`;
+  return repoUrl;
+};
+
 export const jfRegistryUrl = 'registry.paperout.com';

package/src/next/deploy.js

@@ -3,8 +3,11 @@ import path from 'path';
 import yaml from 'js-yaml';
 import { $ } from 'zx';
 import lodash from 'lodash';
-import { appInfo, getBitbucketInfo } from './config.js';
+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';
 
 /**
  * Clone the repository, read the YAML file, and return the parsed data and file paths.
@@ -21,8 +24,7 @@ function getRepoLocalPath(env) {
 
 async function cloneEnvRepository(env) {
   const { repoPath, repoName } = getRepoLocalPath(env);
-  const { username, password } = getBitbucketInfo();
-  const repoUrl = `https://${username}:${password}@bitbucket.org/dp-cloud/${repoName}.git`;
+  const repoUrl = getRepUrl(repoName);
   console.log(`Cloning repository: ${repoName}`);
   await $`git clone ${repoUrl}`;
   console.log(`Repository cloned to: ${repoPath}`);
@@ -57,7 +59,7 @@ async function readDeployConfig(application, env, site) {
 export async function cloneAndReadDeployConfig(application, env, site) {
   const repoPath = await cloneEnvRepository(env);
 
-  const { deployConfig, deployConfigFilePath } = readDeployConfig(
+  const { deployConfig, deployConfigFilePath } = await readDeployConfig(
     application,
     env,
     site,
@@ -107,7 +109,7 @@ export async function pushDeployConfig(repoPath, commitMessage) {
   console.log('📌 Committing changes to the repository...');
   await $`cd ${repoPath} && git config user.email "gitops@docupace.com"`;
   await $`cd ${repoPath} && git add .`;
-  await $`cd ${repoPath} && git commit -m "${commitMessage}"`;
+  await $`cd ${repoPath} && git commit -m ${commitMessage}`;
   await $`cd ${repoPath} && git push`;
   console.log('✅ Changes pushed to the remote repository.');
 
@@ -187,7 +189,72 @@ export async function deploy(application, site) {
   console.log('Deployment completed successfully.');
 }
 
-export async function deployFromSite(fromEnv, fromSite, toEnv, toSite) {
+async function getAppInfo(coreUrl) {
+  const url = `${coreUrl}/b2b/rest/v1/appinfo`;
+  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;
+  }
+
+  // Otherwise, use the full version
+  return fullVersion;
+}
+
+async function getCoreBranchName(fromEnv, fromSite) {
+  const envConfig = environmentConfig[fromEnv];
+  const oldUrl = envConfig.oldUrl(fromSite);
+  const newUrl = envConfig.newUrl(fromSite) + '/core';
+
+  let appinfo;
+  try {
+    appinfo = await getAppInfo(oldUrl);
+  } catch {
+    try {
+      appinfo = await getAppInfo(newUrl);
+    } catch {
+      throw new Error('Cannot get app info');
+    }
+  }
+
+  const coreVersion = appinfo.data.core.version;
+  const branchName = getBranchNameFromVersion(coreVersion);
+  return branchName;
+}
+
+export async function deployFromSite(
+  fromEnv,
+  fromSite,
+  toEnv,
+  toSite,
+  isDeployCore,
+) {
+  if (isDeployCore === 'true') {
+    const branchName = await getCoreBranchName(fromEnv, fromSite);
+    await deployCore(toEnv, toSite, 'true', branchName);
+
+    // To be added back when splitting between on prem and in cloud
+    /*await runPipeline('site-deploy', 'deploy-core', 'main', {
+      ENV: toEnv,
+      SITE: toSite,
+      LIQUIBASE: 'true',
+      BRANCH: branchName,
+    });*/
+  }
+
   // Clone repositories for source and target environments
   const fromRepoPath = await cloneEnvRepository(fromEnv);
   const toRepoPath =

package/src/next/jenkins.js

@@ -4,19 +4,21 @@ const JENKINS_URL = 'http://devops.corp.docupace.com';
 const JOB_NAME = 'auto-deploy-site';
 const USERNAME = process.env.CORE_JENKINS_USERNAME;
 const API_TOKEN = process.env.CORE_JENKINS_API_TOKEN;
-const PARAMETERS = {
-  environment: 'dev',
-  site: 'TEMPLATE',
-  runLiquibase: 'true',
-};
 
-export async function triggerJenkinsJob() {
+export async function deployCore(env, site, liquibase, gitBranch) {
+  const parameters = {
+    environment: env,
+    site: site.toUpperCase(),
+    runLiquibase: liquibase,
+    gitBranch,
+  };
+
   try {
     // Trigger the job
     console.log('Triggering Jenkins job...');
     const buildResponse = await axios.post(
       `${JENKINS_URL}/job/${JOB_NAME}/buildWithParameters`,
-      new URLSearchParams(PARAMETERS),
+      new URLSearchParams(parameters),
       {
         auth: { username: USERNAME, password: API_TOKEN },
         headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
@@ -34,7 +36,6 @@ export async function triggerJenkinsJob() {
         auth: { username: USERNAME, password: API_TOKEN },
       });
       jobUrl = queueResponse.data.executable?.url || null;
-      jobUrl = jobUrl.replaceAll('https', 'http');
 
       if (!jobUrl) {
         console.log('Waiting for job to start...');
@@ -42,6 +43,8 @@ export async function triggerJenkinsJob() {
       }
     }
 
+    jobUrl = jobUrl.replaceAll('https', 'http');
+
     console.log(`Job started at: ${jobUrl}`);
 
     // Stream console output

package/src/next/pipline.js

@@ -0,0 +1,94 @@
+import axios from 'axios';
+import { getBitbucketInfo } from './config.js';
+
+const BITBUCKET_BASE_URL = 'https://api.bitbucket.org/2.0';
+
+async function triggerPipelineByName(
+  repository,
+  pipelineName,
+  branch,
+  variables,
+) {
+  const { username, password, workspace } = getBitbucketInfo();
+  const url = `${BITBUCKET_BASE_URL}/repositories/${workspace}/${repository}/pipelines/`;
+  const auth = {
+    username: username,
+    password: password,
+  };
+
+  const payload = {
+    target: {
+      type: 'pipeline_ref_target',
+      ref_type: 'branch',
+      ref_name: branch,
+      selector: {
+        type: 'custom',
+        pattern: pipelineName,
+      },
+    },
+    variables: Object.entries(variables).map(([key, value]) => ({
+      key,
+      value,
+      secured: false, // Set to true if the variable should be secure
+    })),
+  };
+
+  try {
+    const response = await axios.post(url, payload, { auth });
+    return response.data;
+  } catch (error) {
+    console.error(
+      'Error triggering custom pipeline:',
+      error.response?.data || error.message,
+    );
+    throw error;
+  }
+}
+
+async function getPipelineStatus(repository, pipelineUUID) {
+  const { username, password, workspace } = getBitbucketInfo();
+  const url = `${BITBUCKET_BASE_URL}/repositories/${workspace}/${repository}/pipelines/${pipelineUUID}`;
+  const auth = {
+    username: username,
+    password: password,
+  };
+
+  try {
+    const response = await axios.get(url, { auth });
+    return response.data.state.name;
+  } catch (error) {
+    console.error(
+      'Error fetching pipeline status:',
+      error.response?.data || error.message,
+    );
+    throw error;
+  }
+}
+
+export async function runPipeline(repository, pipelineName, branch, variables) {
+  try {
+    console.log(
+      `Triggering custom pipeline: ${pipelineName} for branch: ${branch}...`,
+    );
+    const pipeline = await triggerPipelineByName(
+      repository,
+      pipelineName,
+      branch,
+      variables,
+    );
+    const pipelineUUID = pipeline.uuid;
+
+    console.log(`Pipeline triggered with UUID: ${pipelineUUID}`);
+    let status = '';
+    do {
+      console.log('Checking pipeline status...');
+      await new Promise((resolve) => setTimeout(resolve, 10000)); // Wait 10 seconds
+      status = await getPipelineStatus(repository, pipelineUUID);
+      console.log(`Pipeline status: ${status}`);
+    } while (['IN_PROGRESS', 'PENDING', 'RUNNING'].includes(status));
+
+    console.log(`Pipeline completed with status: ${status}`);
+  } catch (error) {
+    console.error('Error monitoring pipeline:', error.message);
+  }
+}