@docupace/pipeline 1.0.6 → 1.0.7-7.micro-cli

package/src/merge/pr.js

@@ -0,0 +1,231 @@
+/**
+ * Create a Bitbucket pull request
+ * @param {string} sourceBranch - Source branch name
+ * @param {string} targetBranch - Target branch name
+ * @param {string} title - PR title
+ * @param {string} description - PR description
+ * @returns {Promise<Object>} - PR creation result
+ */
+import { execSync } from 'child_process';
+
+/**
+ * Check for existing pull requests with specific description pattern
+ * @param {string} descriptionPattern - Pattern to match in PR descriptions
+ * @returns {Promise<Object[]>} - Array of matching PRs
+ */
+export async function getExistingPRsWithDescription(
+  descriptionPattern,
+  repositories,
+) {
+  // If no repositories provided, fall back to current repo behavior for backward compatibility
+  if (!repositories || !Array.isArray(repositories)) {
+    return getExistingPRsFromCurrentRepo(descriptionPattern);
+  }
+
+  try {
+    // Check for Bitbucket credentials
+    const username = process.env.BITBUCKET_USERNAME;
+    const password = process.env.BITBUCKET_APP_PASSWORD;
+
+    if (!username || !password) {
+      console.log(
+        `\n⚠️  Bitbucket credentials not found. Cannot check existing PRs.`,
+      );
+      return [];
+    }
+
+    const auth = Buffer.from(`${username}:${password}`).toString('base64');
+    const allMatchingPRs = [];
+
+    // Check each repository for matching PRs
+    for (const repo of repositories) {
+      try {
+        const match = repo.url.match(/bitbucket\.org[\/:]([^\/]+)\/([^\/\.]+)/);
+
+        if (!match) {
+          console.warn(`Could not parse repository URL: ${repo.url}`);
+          continue;
+        }
+
+        const [, workspace, repoSlug] = match;
+
+        const response = await fetch(
+          `https://api.bitbucket.org/2.0/repositories/${workspace}/${repoSlug}/pullrequests?state=OPEN`,
+          {
+            method: 'GET',
+            headers: {
+              Authorization: `Basic ${auth}`,
+              'Content-Type': 'application/json',
+            },
+          },
+        );
+
+        if (!response.ok) {
+          const error = await response.text();
+          console.warn(
+            `Bitbucket API error for ${repo.name}: ${response.status} - ${error}`,
+          );
+          continue;
+        }
+
+        const data = await response.json();
+        const matchingPRs = data.values.filter(
+          (pr) =>
+            pr.description && pr.description.startsWith(descriptionPattern),
+        );
+
+        // Add repository info to each PR for context
+        matchingPRs.forEach((pr) => {
+          pr.repositoryName = repo.name;
+          pr.repositoryUrl = repo.url;
+        });
+
+        allMatchingPRs.push(...matchingPRs);
+      } catch (error) {
+        console.warn(
+          `Failed to check PRs for repository ${repo.name}: ${error.message}`,
+        );
+      }
+    }
+
+    return allMatchingPRs;
+  } catch (error) {
+    console.error(`Failed to get existing PRs: ${error.message}`);
+    return [];
+  }
+}
+
+/**
+ * Legacy function for backward compatibility - checks PRs in current repo only
+ */
+export async function getExistingPRsFromCurrentRepo(descriptionPattern) {
+  try {
+    // Get Bitbucket workspace and repo from git remote
+    const remoteUrl = execSync('git config --get remote.origin.url', {
+      encoding: 'utf-8',
+    }).trim();
+    const match = remoteUrl.match(/bitbucket\.org[\/:]([^\/]+)\/([^\/\.]+)/);
+
+    if (!match) {
+      throw new Error(
+        'Could not parse Bitbucket workspace and repository from remote URL',
+      );
+    }
+
+    const [, workspace, repoSlug] = match;
+
+    // Check for Bitbucket credentials
+    const username = process.env.BITBUCKET_USERNAME;
+    const password = process.env.BITBUCKET_APP_PASSWORD;
+
+    if (!username || !password) {
+      console.log(
+        `\n⚠️  Bitbucket credentials not found. Cannot check existing PRs.`,
+      );
+      return [];
+    }
+
+    const auth = Buffer.from(`${username}:${password}`).toString('base64');
+    const response = await fetch(
+      `https://api.bitbucket.org/2.0/repositories/${workspace}/${repoSlug}/pullrequests?state=OPEN`,
+      {
+        method: 'GET',
+        headers: {
+          Authorization: `Basic ${auth}`,
+          'Content-Type': 'application/json',
+        },
+      },
+    );
+
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Bitbucket API error: ${response.status} - ${error}`);
+    }
+
+    const data = await response.json();
+    const matchingPRs = data.values.filter(
+      (pr) => pr.description && pr.description.startsWith(descriptionPattern),
+    );
+
+    return matchingPRs;
+  } catch (error) {
+    console.error(`Failed to get existing PRs: ${error.message}`);
+    return [];
+  }
+}
+
+export async function createBitbucketPR(
+  sourceBranch,
+  targetBranch,
+  title,
+  description,
+) {
+  try {
+    // Get Bitbucket workspace and repo from git remote
+    const remoteUrl = execSync('git config --get remote.origin.url', {
+      encoding: 'utf-8',
+    }).trim();
+    const match = remoteUrl.match(/bitbucket\.org[\/:]([^\/]+)\/([^\/\.]+)/);
+
+    if (!match) {
+      throw new Error(
+        'Could not parse Bitbucket workspace and repository from remote URL',
+      );
+    }
+
+    const [, workspace, repoSlug] = match;
+
+    // Check for Bitbucket credentials
+    const username = process.env.BITBUCKET_USERNAME;
+    const password = process.env.BITBUCKET_APP_PASSWORD;
+
+    if (!username || !password) {
+      console.log(
+        `\n⚠️  Bitbucket credentials not found in environment variables.`,
+      );
+      console.log(
+        'Please set BITBUCKET_USERNAME and BITBUCKET_APP_PASSWORD to auto-create PR.',
+      );
+      console.log(
+        `Manual PR creation URL: https://bitbucket.org/${workspace}/${repoSlug}/pull-requests/new?source=${sourceBranch}&dest=${targetBranch}`,
+      );
+      return {
+        success: false,
+        manual: true,
+        url: `https://bitbucket.org/${workspace}/${repoSlug}/pull-requests/new?source=${sourceBranch}&dest=${targetBranch}`,
+      };
+    }
+
+    // Create PR via Bitbucket API
+    const prData = {
+      title,
+      description,
+      source: { branch: { name: sourceBranch } },
+      destination: { branch: { name: targetBranch } },
+    };
+
+    const auth = Buffer.from(`${username}:${password}`).toString('base64');
+    const response = await fetch(
+      `https://api.bitbucket.org/2.0/repositories/${workspace}/${repoSlug}/pullrequests`,
+      {
+        method: 'POST',
+        headers: {
+          Authorization: `Basic ${auth}`,
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(prData),
+      },
+    );
+
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Bitbucket API error: ${response.status} - ${error}`);
+    }
+
+    const pr = await response.json();
+    return { success: true, pr, url: pr.links.html.href };
+  } catch (error) {
+    console.error(`Failed to create Bitbucket PR: ${error.message}`);
+    return { success: false, error: error.message };
+  }
+}

package/src/micro/cli.js

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import { publishMicroservice } from './ms-publish.js';
+
+import dotenv from 'dotenv';
+import {
+  deployMicroserviceEndToEnd,
+  promoteMicroserviceImage,
+  testMicroserviceDeploy,
+  testMicroservicePublish,
+} from './ms-deploy.js';
+
+dotenv.config({ path: ['.env.pipeline.local', 'config/.env.pipeline.local'] });
+
+const program = new Command();
+
+//const GIT_SHA = (await $`git log --pretty=format:'%h' -n 1`).stdout.trim();
+
+// Add the new publish-microservice command
+program
+  .command('publish-microservice <serviceName>')
+  .description('Publish a microservice Docker image with version tags')
+  .option('-t, --tag <tag>', 'Version tag (defaults to BITBUCKET_TAG)')
+  .action(async (serviceName, options) => {
+    await publishMicroservice(serviceName, options);
+  });
+
+program
+  .command('deploy-microservice <repoName>')
+  .description('Deploy microservice end-to-end (build + publish + deploy)')
+  .option('-e, --env <environment>', 'Target environment', 'dev')
+  .option('-t, --tag <tag>', 'Version tag (defaults to BITBUCKET_TAG)')
+  .action(async (repoName, options) => {
+    await deployMicroserviceEndToEnd(repoName, options.env, options.tag);
+  });
+
+program
+  .command('promote-microservice <repoName>')
+  .description('Promote microservice image between environments')
+  .requiredOption('-f, --from <fromEnv>', 'Source environment')
+  .requiredOption('-t, --to <toEnv>', 'Target environment')
+  .requiredOption('-g, --tag <tag>', 'Image tag to promote')
+  .action(async (repoName, options) => {
+    await promoteMicroserviceImage(
+      repoName,
+      options.from,
+      options.to,
+      options.tag,
+    );
+  });
+
+program
+  .command('test-deploy-microservice <serviceName>')
+  .description('Test microservice deployment only (no image building)')
+  .option('-e, --env <environment>', 'Target environment', 'dev')
+  .option('-t, --tag <tag>', 'Version tag', 'v0.1.0')
+  .action(async (serviceName, options) => {
+    await testMicroserviceDeploy(serviceName, options.env, options.tag);
+  });
+
+program
+  .command('test-publish-microservice <serviceName>')
+  .description(
+    'Test microservice Docker build and publish only (no deployment)',
+  )
+  .action(async (serviceName) => {
+    await testMicroservicePublish(serviceName);
+  });
+
+program.parse(process.argv);

package/src/micro/ms-deploy.js

@@ -0,0 +1,273 @@
+import { $ } from '../next/logger.js';
+import { publishMicroservice } from './ms-publish.js';
+import { copy2 } from '../next/copy.js';
+import fs from 'fs';
+import path from 'path';
+/**
+ * Deploy microservice end-to-end: build, publish, and deploy
+ * @param {string} repoName - Name of microservice (e.g., 'swp', 'fidelity', 'esp')
+ * @param {string} environment - Target environment (dev, qa, uat, stage, prod)
+ * @param {string} tag - Version tag (optional, defaults to BITBUCKET_TAG)
+ */
+export async function deployMicroserviceEndToEnd(
+  repoName,
+  environment = '',
+  tag = null,
+) {
+  const serviceName = String(repoName || '')
+    .split('-')
+    .pop()
+    .trim();
+  const registryUrl = process.env.JF_REGISTRY_URL || '';
+  const deployTag = tag || process.env.BITBUCKET_TAG || process.env.VERSION_TAG;
+  if (!deployTag) {
+    throw new Error(
+      'No tag provided. Set tag parameter or BITBUCKET_TAG/VERSION_TAG environment variable.',
+    );
+  }
+  console.log(`Starting ${serviceName} microservice deployment...`);
+  console.log(`Environment: ${environment}`);
+  console.log(`Tag: ${deployTag}`);
+  console.log('==========================================');
+  try {
+    // Step 1: Get Git SHA for image building
+    const gitSha = (
+      await $`git log ${deployTag} --pretty=format:'%h' -n 1`
+    ).stdout.trim();
+    console.log(`Git SHA: ${gitSha}`);
+    // Step 2: Publish Docker image with version tags
+    console.log('\nPublishing Docker image...');
+    await publishMicroservice(serviceName, {
+      tag: deployTag,
+    });
+    console.log('Docker image published successfully!');
+    // Step 3: Deploy to GitOps repository
+    console.log(`\nDeploying to ${environment} environment...`);
+    await deployMicroservice(serviceName, serviceName, environment, deployTag);
+    console.log(`Deployment to ${environment} completed successfully!`);
+    console.log(
+      `\n${serviceName} microservice deployment completed successfully!`,
+    );
+    console.log(
+      `Image: ${registryUrl}/${repoName}-${environment}-docker-local/${serviceName}:${deployTag}`,
+    );
+  } catch (error) {
+    console.error('\nDeployment failed:', error.message);
+    throw error;
+  }
+}
+/**
+ * Promote microservice image between environments
+ * @param {string} repoName - Name of microservice
+ * @param {string} fromEnv - Source environment
+ * @param {string} toEnv - Target environment
+ * @param {string} tag - Image tag to promote
+ */
+export async function promoteMicroserviceImage(repoName, fromEnv, toEnv, tag) {
+  const serviceName = String(repoName || '')
+    .split('-')
+    .pop()
+    .trim();
+  console.log(`Starting ${serviceName} image promotion...`);
+  console.log(`From: ${fromEnv} → To: ${toEnv}`);
+  console.log(`Tag: ${tag}`);
+  console.log('==========================================');
+  try {
+    // Step 1: Copy Docker image between registries
+    console.log('\nCopying Docker image...');
+    const repositoryName = `${repoName}`;
+    await copy2(repositoryName, fromEnv, toEnv, tag, serviceName);
+    console.log('Docker image copied successfully!');
+    // Step 2: Deploy to target environment
+    console.log(`\nDeploying to ${toEnv} environment...`);
+    await deployMicroservice(serviceName, serviceName, toEnv, tag);
+    console.log(`Deployment to ${toEnv} completed successfully!`);
+    console.log(`\n${serviceName} image promotion completed successfully!`);
+  } catch (error) {
+    console.error('\nImage promotion failed:', error.message);
+    throw error;
+  }
+}
+/**
+ * Test deployment only (no image building)
+ * @param {string} serviceName - Name of microservice
+ * @param {string} environment - Target environment
+ * @param {string} tag - Version tag
+ */
+export async function testMicroserviceDeploy(
+  serviceName,
+  environment = 'dev',
+  tag = 'v0.1.0',
+) {
+  console.log(`Starting ${serviceName} test deployment...`);
+  console.log(`Environment: ${environment}`);
+  console.log(`Tag: ${tag}`);
+  console.log('==========================================');
+  try {
+    console.log(`\nTesting deployment to ${environment}...`);
+    await deployMicroservice(serviceName, serviceName, environment, tag);
+    console.log(`Test deployment to ${environment} completed successfully!`);
+  } catch (error) {
+    console.error('\nTest deployment failed:', error.message);
+    throw error;
+  }
+}
+/**
+ * Test Docker build and publish only (no deployment)
+ * @param {string} serviceName - Name of microservice
+ */
+export async function testMicroservicePublish(serviceName) {
+  console.log(`Starting ${serviceName} test publish...`);
+  console.log('==========================================');
+  try {
+    const gitSha = (await $`git log --pretty=format:'%h' -n 1`).stdout.trim();
+    console.log(`Git SHA: ${gitSha}`);
+    console.log('\nTesting Docker build and publish...');
+    await publishMicroservice(gitSha, {
+      imageName: serviceName,
+    });
+    console.log('Test publish completed successfully!');
+  } catch (error) {
+    console.error('\nTest publish failed:', error.message);
+    throw error;
+  }
+}
+
+/////
+
+export async function deployMicroservice(
+  appName,
+  helmPath,
+  environment = '',
+  tag = null,
+) {
+  if (!appName || !helmPath) {
+    throw new Error(
+      'Missing required parameters. Usage: deployMicroservice(appName, helmPath, [environment], [tag])',
+    );
+  }
+
+  let deployTag = tag;
+  if (!deployTag) {
+    deployTag =
+      process.env.VERSION_TAG ||
+      process.env.BITBUCKET_TAG ||
+      (process.env.BITBUCKET_BUILD_NUMBER
+        ? `build-${process.env.BITBUCKET_BUILD_NUMBER}`
+        : null);
+  }
+
+  if (!deployTag) {
+    throw new Error(
+      'No tag specified and no default tag available from environment variables',
+    );
+  }
+
+  const repoName = `gitops-${environment}`;
+  const filePath = `dp/${helmPath}/${appName}.values.yaml`;
+
+  const gitopsBranch =
+    environment === 'dev' || environment === 'uat'
+      ? process.env.GITOPS_BRANCH || 'master'
+      : process.env.GITOPS_BRANCH || 'main';
+
+  let repoUrl;
+  if (environment === 'dev' && process.env.GITOPS_REP_TOKEN) {
+    repoUrl = `https://x-token-auth:${process.env.GITOPS_REP_TOKEN}@bitbucket.org/dp-cloud/${repoName}.git`;
+  } else if (
+    process.env.BITBUCKET_USERNAME &&
+    process.env.BITBUCKET_APP_PASSWORD
+  ) {
+    repoUrl = `https://${process.env.BITBUCKET_USERNAME}:${process.env.BITBUCKET_APP_PASSWORD}@bitbucket.org/dp-cloud/${repoName}.git`;
+  } else {
+    throw new Error(
+      'No authentication credentials found for GitOps repository',
+    );
+  }
+
+  console.log('=========================================');
+  console.log('Microservice Deployment Configuration');
+  console.log('=========================================');
+  console.log(`Application: ${appName}`);
+  console.log(`Environment: ${environment}`);
+  console.log(`Tag: ${deployTag}`);
+  console.log(`GitOps Repo: ${repoName}`);
+  console.log(`Values File: ${filePath}`);
+  console.log(`Branch: ${gitopsBranch}`);
+  console.log('=========================================');
+
+  try {
+    console.log('Cloning GitOps repository...');
+    await $`git clone --depth 1 ${repoUrl} ${repoName}`;
+
+    console.log('Checking if directory exists...');
+    await $`ls -la ${repoName}`;
+
+    console.log(`Changing to directory: ${repoName}`);
+    const originalDir = process.cwd();
+    process.chdir(repoName);
+
+    console.log('Verifying directory change...');
+    const newDir = process.cwd();
+    console.log(`Original: ${originalDir}`);
+    console.log(`New: ${newDir}`);
+
+    await $`cd ${repoName} && git config user.email "pipeline@bitbucket.org"`;
+    await $`cd ${repoName} && git config user.name "Bitbucket Pipeline"`;
+
+    console.log(`Attempting to checkout branch: ${gitopsBranch}`);
+    await $`cd ${repoName} && git checkout ${gitopsBranch}`;
+
+    const fullFilePath = path.resolve(filePath);
+    console.log(`Looking for file at: ${fullFilePath}`);
+    if (!fs.existsSync(fullFilePath)) {
+      throw new Error(
+        `Values file ${filePath} does not exist in ${repoName} on branch ${gitopsBranch}`,
+      );
+    }
+
+    console.log(`Updating image tag to ${deployTag}...`);
+
+    let fileContent = fs.readFileSync(fullFilePath, 'utf8');
+
+    const tagRegex = /^ {2}tag: .*/gm;
+    const newContent = fileContent.replace(tagRegex, `  tag: ${deployTag}`);
+
+    if (fileContent === newContent) {
+      console.log(`No changes detected - tag is already ${deployTag}`);
+      return;
+    }
+
+    fs.writeFileSync(fullFilePath, newContent, 'utf8');
+
+    console.log('Changes to be committed:');
+    await $`cd ${repoName} && git diff ${filePath}`;
+
+    await $`cd ${repoName} && git add ${filePath}`;
+    await $`cd ${repoName} && git commit -m "Update ${appName} image tag to ${deployTag} in ${environment} environment"`;
+
+    console.log('Pushing changes to GitOps repository...');
+    await $`cd ${repoName} && git push origin ${gitopsBranch}`;
+
+    console.log('=========================================');
+    console.log(
+      `✅ Successfully deployed ${appName}:${deployTag} to ${environment}`,
+    );
+    console.log('=========================================');
+  } catch (error) {
+    console.error('Error during microservice deployment:', error.message);
+    throw error;
+  } finally {
+    try {
+      process.chdir('..');
+      await $`rm -rf ${repoName}`;
+    } catch (cleanupError) {
+      console.warn(
+        'Warning: Failed to clean up temporary directory:',
+        cleanupError.message,
+      );
+    }
+  }
+}
+
+export default deployMicroservice;