@docupace/pipeline 1.0.81-alpha.9 → 1.0.82

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "@docupace/pipeline",
-  "version": "1.0.81-alpha.9",
+  "version": "1.0.82",
   "main": "index.js",
   "type": "module",
   "bin": {
     "dp-changeset-cli": "src/changeset/cli.js",
     "dp-next-cli": "src/next/cli.js",
     "dp-auth0-cli": "src/auth0/cli.js",
-    "dp-merge-cli": "src/merge/cli.js"
+    "dp-merge-cli": "src/merge/cli.js",
+    "dp-micro-cli": "src/micro/cli.js"
   },
   "keywords": [
     "bash"

package/src/merge/cli-merge-all.js

@@ -226,10 +226,6 @@ async function runPreparePhase(
       case 4:
         console.log(`✅ ${configName}: No Changes`);
         break;
-      case 5:
-        console.log(`❌ Stopping Merge`);
-        process.exit(1);
-        break;
       default:
         console.log(
           `❌ ${configName}: Unknown error (exit code: ${result.exitCode})`,
@@ -386,7 +382,7 @@ async function mergeAll(verbose = false) {
       config.repositories,
     );
 
-    /*if (existingPRs.length > 0) {
+    if (existingPRs.length > 0) {
       console.log(
         `❌ Found ${existingPRs.length} existing pull request(s) with "Automated merge with changeset" description. Exiting to prevent conflicts.`,
       );
@@ -398,7 +394,7 @@ async function mergeAll(verbose = false) {
         });
       }
       process.exit(1);
-    }*/
+    }
 
     if (verbose)
       console.log('✅ No existing automated merge PRs found. Proceeding...');
@@ -432,15 +428,6 @@ async function mergeAll(verbose = false) {
         verbose,
       );
 
-      if (
-        branchResult.success &&
-        branchResult.summary.successes > 0 &&
-        i < config.mergeBranches.length - 1
-      ) {
-        console.log('Pausing before next merge');
-        await new Promise((res) => setTimeout(res, 90000));
-      }
-
       if (!branchResult.success) {
         console.log(`Exiting due to failure of one or more merges`);
         process.exit(1);

package/src/merge/cli-merge.js

@@ -216,27 +216,9 @@ function mergeIntoTarget(
       stdio: verbose ? 'inherit' : 'pipe',
     });
 
-    // Delete local merge branch
-    try {
-      execSync(`git branch -d ${mergeBranchName}`, {
-        stdio: 'pipe',
-      });
-      if (verbose)
-        console.log(`🗑️  Deleted local merge branch: ${mergeBranchName}`);
-    } catch {
-      // Branch doesn't exist, which is fine
-    }
-
-    // Delete remote merge branch
-    try {
-      execSync(`git push origin --delete ${mergeBranchName}`, {
-        stdio: 'pipe',
-      });
-      if (verbose)
-        console.log(`🗑️  Deleted remote merge branch: ${mergeBranchName}`);
-    } catch (e) {
-      console.error('Failed to delete remote branch', e);
-    }
+    execSync(`git branch -d ${mergeBranchName}`, {
+      stdio: verbose ? 'inherit' : 'pipe',
+    });
 
     if (verbose) console.log(`✅ Successfully merged into ${targetBranch}`);
   } else {
@@ -287,62 +269,6 @@ function cleanupFailedMerge(verbose = false) {
   }
 }
 
-/**
- * Check if source branch has uncommitted changesets
- */
-function checkForUncommittedChangesets(sourceBranch, verbose = false) {
-  if (verbose)
-    console.log(`🔍 Checking for uncommitted changesets in ${sourceBranch}`);
-
-  // Store current branch
-  const currentBranch = execSync('git branch --show-current', {
-    encoding: 'utf8',
-    stdio: 'pipe',
-  }).trim();
-
-  try {
-    // Checkout source branch
-
-    execSync(`git checkout ${sourceBranch}`, {
-      stdio: 'pipe',
-    });
-
-    execSync(`git pull`, {
-      stdio: verbose ? 'inherit' : 'pipe',
-    });
-
-    // Check for .md files in .changeset directory (excluding README.md)
-    try {
-      const changesetFiles = execSync(
-        'find .changeset -name "*.md" -not -name "README.md" 2>/dev/null | head -1',
-        {
-          encoding: 'utf8',
-          stdio: 'pipe',
-        },
-      ).trim();
-
-      if (changesetFiles) {
-        console.log(
-          `❌ Cannot merge a branch where version has not been bumped. Found changesets in ${sourceBranch}`,
-        );
-        process.exit(5);
-      }
-    } catch (error) {
-      if (error.message.includes('Cannot merge')) {
-        throw error;
-      }
-      // If find command fails (no .changeset directory), that's fine
-    }
-
-    if (verbose) console.log('✅ No uncommitted changesets found');
-  } finally {
-    // Return to original branch
-    execSync(`git checkout ${currentBranch}`, {
-      stdio: 'pipe',
-    });
-  }
-}
-
 export function setupMerge(program) {
   program
     .command('merge')
@@ -380,11 +306,6 @@ export function setupMerge(program) {
           );
         }
 
-        // Check for uncommitted changesets in source branch
-        if (!mergeFail && !mergeSuccess) {
-          checkForUncommittedChangesets(sourceBranch, verbose);
-        }
-
         // 1. Create merge branch from target branch
         const mergeBranchName = createMergeBranch(
           sourceBranch,

package/src/micro/cli.js

@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+//import { publishMicroservice } from './ms-publish.js';
+
+import dotenv from 'dotenv';
+import {
+  microserviceDeployTagVersion,
+  microserviceCopyImageToEnv,
+  microserviceBuildPushImage,
+} 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();
+
+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 (repoName, options) => {
+    await microserviceBuildPushImage(repoName, 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 microserviceDeployTagVersion(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 microserviceCopyImageToEnv(
+      repoName,
+      options.from,
+      options.to,
+      options.tag,
+    );
+  });
+
+program.parse(process.argv);

package/src/micro/ms-deploy.js

@@ -0,0 +1,451 @@
+import { $ } from '../next/logger.js';
+//mport { 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;
+//   }
+// }
+
+/**
+ * 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-svc/${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;
+
+export async function microserviceDeployTagVersion(
+  repoName,
+  environment = '',
+  tag = null,
+) {
+  const serviceName = String(repoName || '')
+    .split('-')
+    .pop()
+    .trim();
+  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;
+  }
+}
+
+export async function microserviceCopyImageToEnv(
+  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!');
+  } catch (error) {
+    console.error('\nImage promotion failed:', error.message);
+    throw error;
+  }
+}
+
+export async function microserviceBuildPushImage(repoName, options = {}) {
+  // Use environment variables as defaults, but allow overrides
+
+  const serviceName = String(repoName || '')
+    .split('-')
+    .pop()
+    .trim();
+  const config = {
+    imageName: serviceName,
+    registryUrl: options.registryUrl || process.env.JF_REGISTRY_URL,
+    repoName: repoName,
+    username: options.username || process.env.JF_REGISTRY_DEV_USERNAME,
+    password: options.password || process.env.JF_REGISTRY_DEV_PASSWORD,
+    buildNumber: options.buildNumber || process.env.BITBUCKET_BUILD_NUMBER,
+    tag: options.tag || process.env.VERSION_TAG,
+  };
+
+  // Validate required fields
+  if (!config.imageName) {
+    throw new Error(
+      'Image name is required. Set IMAGE_NAME or APP_NAME environment variable.',
+    );
+  }
+  console.log('=== Docker Image Publishing Configuration ===');
+  console.log(`Version Tag: ${config.tag || 'none'}`);
+  console.log(`Registry: ${config.registryUrl}/${repoName}`);
+  console.log('==========================================');
+
+  const registryPath = `${config.registryUrl}/${repoName}-dev-docker-local`;
+  // Docker login
+  await $`echo ${config.password} | docker login --username ${config.username} --password-stdin ${config.registryUrl}`;
+
+  try {
+    // Build the image if it doesn't exist locally
+    const TAG_IMAGE_NAME = `${registryPath}/${serviceName}:${options.tag}`;
+    const imageExists = await checkLocalImage(TAG_IMAGE_NAME);
+    let SHA_IMAGE_NAME = '';
+    if (!imageExists) {
+      const repoUrl = `https://${process.env.BITBUCKET_USERNAME}:${process.env.BITBUCKET_APP_PASSWORD}@bitbucket.org/dp-cloud/${repoName}.git`;
+      await $`git clone --branch ${options.tag} --depth 1 ${repoUrl} ${repoName}`;
+
+      console.log('Checking if directory exists...');
+      await $`ls -la ${repoName}`;
+
+      console.log(`Changing to directory: ${repoName}`);
+      process.chdir(repoName);
+
+      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: ${options.tag}`);
+
+      const gitSha = (
+        await $`cd ${repoName} && git log ${options.tag} --pretty=format:'%h' -n 1 `
+      ).stdout.trim();
+      SHA_IMAGE_NAME = `${config.imageName}:sha-${gitSha}`;
+
+      console.log(`Building Docker image ${SHA_IMAGE_NAME}...`);
+      await $`cd ${repoName} && docker build -t ${SHA_IMAGE_NAME} .`;
+    }
+
+    // Array to track all tags we're pushing
+    const tagsToPush = [];
+
+    // 1. Push SHA tag
+    const shaTag = `${registryPath}/${SHA_IMAGE_NAME}`;
+    console.log(`Tagging and pushing SHA: ${shaTag}`);
+    await $`docker tag ${SHA_IMAGE_NAME} ${shaTag}`;
+    await $`docker push ${shaTag}`;
+    tagsToPush.push(SHA_IMAGE_NAME);
+
+    // 2. Push build number tag
+    if (config.buildNumber) {
+      const BUILD_IMAGE_NAME = `${config.imageName}:${config.buildNumber}`;
+      const buildTag = `${registryPath}/${BUILD_IMAGE_NAME}`;
+      console.log(`Tagging and pushing build: ${buildTag}`);
+      await $`docker tag ${SHA_IMAGE_NAME} ${buildTag}`;
+      await $`docker push ${buildTag}`;
+      tagsToPush.push(BUILD_IMAGE_NAME);
+    }
+
+    // 3. Push version tag (this is what ArgoCD needs!)
+    if (config.tag) {
+      // Handle various tag formats
+      let version = config.tag;
+
+      // If tag contains @, extract version after it
+      if (version.includes('@')) {
+        version = 'v' + version.split('@')[1];
+      }
+
+      // Ensure version starts with 'v' if it's a semver without it
+      if (/^\d+\.\d+\.\d+/.test(version) && !version.startsWith('v')) {
+        version = 'v' + version;
+      }
+
+      const VERSION_IMAGE_NAME = `${config.imageName}:${version}`;
+      const versionTag = `${registryPath}/${VERSION_IMAGE_NAME}`;
+
+      console.log(`Tagging and pushing version: ${versionTag}`);
+      await $`docker tag ${SHA_IMAGE_NAME} ${versionTag}`;
+      await $`docker push ${versionTag}`;
+      tagsToPush.push(VERSION_IMAGE_NAME);
+
+      // Also push 'latest' tag when we have a version
+      const LATEST_IMAGE_NAME = `${config.imageName}:latest`;
+      const latestTag = `${registryPath}/${LATEST_IMAGE_NAME}`;
+      console.log(`Tagging and pushing latest: ${latestTag}`);
+      await $`docker tag ${SHA_IMAGE_NAME} ${latestTag}`;
+      await $`docker push ${latestTag}`;
+      tagsToPush.push(LATEST_IMAGE_NAME);
+    }
+
+    // 4. Check for git tags at current commit
+    try {
+      const gitTags = (await $`git tag --points-at HEAD`).stdout
+        .trim()
+        .split('\n')
+        .filter(Boolean);
+
+      if (gitTags.length > 0) {
+        console.log(`Found git tags at HEAD: ${gitTags.join(', ')}`);
+
+        for (const gitTag of gitTags) {
+          // Skip if we already handled this tag above
+          if (gitTag === config.tag) continue;
+
+          let version = gitTag;
+          if (version.includes('@')) {
+            version = 'v' + version.split('@')[1];
+          }
+
+          const TAG_IMAGE_NAME = `${config.imageName}:${version}`;
+          const gitTagPath = `${registryPath}/${TAG_IMAGE_NAME}`;
+
+          console.log(`Tagging and pushing git tag: ${gitTagPath}`);
+          await $`docker tag ${SHA_IMAGE_NAME} ${gitTagPath}`;
+          await $`docker push ${gitTagPath}`;
+          tagsToPush.push(TAG_IMAGE_NAME);
+        }
+      }
+    } catch (e) {
+      console.log('No git tags found at HEAD or error checking tags', e);
+    }
+
+    console.log('\n✅ Docker image published successfully!');
+    console.log('=== Summary of pushed tags ===');
+    tagsToPush.forEach((tag) => console.log(`  ✓ ${tag}`));
+    console.log('==============================\n');
+
+    // Verify the version tag if we expect one
+    if (config.tag) {
+      const version = config.tag.includes('@')
+        ? 'v' + config.tag.split('@')[1]
+        : config.tag;
+      const expectedTag = `${registryPath}/${config.imageName}:${version}`;
+      console.log(`Verifying version tag exists: ${expectedTag}`);
+      try {
+        await $`docker manifest inspect ${expectedTag}`;
+        console.log('✅ Version tag verified in registry!');
+      } catch (e) {
+        console.error('❌ WARNING: Could not verify version tag in registry!');
+        console.error('ArgoCD may fail to pull this image.', e);
+      }
+    }
+  } catch (error) {
+    console.error('Error during image publishing:', error);
+    throw error;
+  } finally {
+    // Always logout
+    await $`docker logout ${config.registryUrl}`;
+  }
+}
+
+async function checkLocalImage(imageName) {
+  try {
+    $.verbose = false;
+    await $`docker image inspect ${imageName}`;
+    return true;
+  } catch {
+    return false;
+  } finally {
+    $.verbose = true;
+  }
+}