@docupace/pipeline 1.0.137 → 1.0.138

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @docupace/pipeline
 
+## 1.1.0
+
+### Minor Changes
+
+- 1fb7d37: Add support for Connect deploy
+
 ## 1.0.136
 
 ### Patch Changes

package/README.md

@@ -51,20 +51,28 @@ dp-next-cli [command] [options]
   - `-j, --jira-ticket [jiraTicket]`: JIRA ticket (optional)
   - `-c, --deploy-core <deployCore>`: Deploy Core (default: "false")
   - `-C, --deploy-connect <deployConnect>`: Deploy Connect (default: "false")
+  - `-A, --deploy-connect-aws <deployConnectAws>`: Deploy Connect UI on AWS via `dp-eks-connect-ui-gitops` (default: "false")
 - `update-site-version <env> <site>`: Update specific version components for a site
   - `-u, --ui-version <uiVersion>`: UI image tag
   - `-g, --graph-version <graphVersion>`: GraphQL-server image tag
   - `-S, --standard-config <standardConfig>`: Standard config remote branch
   - `-s, --site-config <siteConfig>`: Site config remote branch
+  - `-c, --connect-version <connectVersion>`: AWS Connect UI image tag (optional)
   - `-j, --jira-ticket [jiraTicket]`: JIRA ticket (required for prod)
 - `deploy-template`: Deploy an application for a specific site
 - `deploy-app <application>`: Deploy an application for a specific site
+  - `deploy-app connect -e <env> -s <site>`: Deploy AWS Connect UI (triggers `deploy-connect-aws` / gitops `update-site-image`)
+  - `-e, --env <env>` / `-s, --site <site>`: Target env/site (optional; otherwise uses auto-deploy targets)
 - `deploy-core <env> <site>`: Deploy Core
   - `-l, --liquibase <liquibase>`: Application name (default: "true")
   - `-b, --branch <branch>`: Branch (default: "master")
 - `deploy-connect <env> <site>`: Deploy Connect
   - `-l, --liquibase <liquibase>`: Application name (default: "true")
   - `-b, --branch <branch>`: Branch (default: "master")
+- `deploy-connect-aws <env> <sites> <version>`: Deploy Connect UI on AWS (updates `dp-eks-connect-ui-gitops` image.tag via Bitbucket pipeline)
+  - `<sites>`: single site or comma-separated list (e.g. `oa` or `oa,athene,template`)
+  - `-b, --branch <branch>`: Gitops branch for the pipeline (default: "main")
+  - `-w, --wait` / `--no-wait`: Wait for pipeline completion (default: wait)
 - `deploy-core-pipeline <env> <site>`: Deploy Core via pipeline
   - `-l, --liquibase <liquibase>`: Application name (default: "true")
   - `-b, --branch <branch>`: Branch (default: "master")
@@ -187,6 +195,13 @@ dp-changeset-cli create-changeset
 
 # Configure Auth0 for a site
 dp-auth0-cli configureFromSite sourceSite targetSite dev prod true true true false
+
+# Deploy Connect UI image tag on AWS (single site or comma-separated sites)
+dp-next-cli deploy-connect-aws qa 1stglobal 4.75.52
+dp-next-cli deploy-connect-aws qa oa,athene,template 4.75.52
+
+# Promote AWS Connect UI version from one site to another via deploy-from-site
+dp-next-cli deploy-from-site -f dev -t qa -F template -T template -A true
 ```
 
 ## License

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@docupace/pipeline",
-  "version": "1.0.137",
+  "version": "1.0.138",
   "description": "",
   "main": "index.js",
   "type": "module",

package/pnpm-workspace.yaml

@@ -1,3 +1,4 @@
 allowBuilds:
+  '@parcel/watcher': true
   esbuild: true
   unrs-resolver: true

package/src/next/cli.js

@@ -20,6 +20,7 @@ import { connectClone } from './connect.js';
 import dotenv from 'dotenv';
 import { $ } from 'zx';
 import { deployConnect, deployCore } from './jenkins.js';
+import { deployConnectAws } from './connect-aws.js';
 import { runPipeline } from './pipline.js';
 
 dotenv.config({ path: ['.env.pipeline.local', 'config/.env.pipeline.local'] });
@@ -93,6 +94,11 @@ program
   .option('-j, --jira-ticket [jiraTicket]', 'JIRA ticket (optional)')
   .option('-c, --deploy-core <deployCore>', 'Deploy Core', 'false')
   .option('-C, --deploy-connect <deployConnect>', 'Deploy Connect', 'false')
+  .option(
+    '-A, --deploy-connect-aws <deployConnectAws>',
+    'Deploy Connect UI on AWS (dp-eks-connect-ui-gitops)',
+    'false',
+  )
   .action(async (options) => {
     const {
       fromEnv,
@@ -101,6 +107,7 @@ program
       toSite,
       deployCore,
       deployConnect,
+      deployConnectAws: deployConnectAwsFlag,
       jiraTicket,
     } = options;
     await deployFromSite(
@@ -111,6 +118,7 @@ program
       deployCore,
       deployConnect,
       jiraTicket,
+      deployConnectAwsFlag,
     );
   });
 
@@ -124,10 +132,20 @@ program
     'Standard config remote branch',
   )
   .option('-s, --site-config <siteConfig>', 'Site config remote branch')
+  .option(
+    '-c, --connect-version <connectVersion>',
+    'AWS Connect UI image tag (triggers deploy-connect-aws)',
+  )
   .option('-j, --jira-ticket [jiraTicket]', 'JIRA ticket (required for prod)')
   .action(async (env, site, options) => {
-    const { uiVersion, graphVersion, standardConfig, siteConfig, jiraTicket } =
-      options;
+    const {
+      uiVersion,
+      graphVersion,
+      standardConfig,
+      siteConfig,
+      connectVersion,
+      jiraTicket,
+    } = options;
     await updateSiteVersion(
       env,
       site,
@@ -136,6 +154,7 @@ program
       standardConfig,
       siteConfig,
       jiraTicket,
+      connectVersion,
     );
   });
 
@@ -174,7 +193,9 @@ program
 
 program
   .command('deploy-app <application>')
-  .description('Deploy an application for a specific site')
+  .description(
+    'Deploy an application for a specific site (use application "connect" for AWS Connect UI)',
+  )
   .option('-e, --env <env>', 'Target environment (overrides default sites)')
   .option('-s, --site <site>', 'Target site (overrides default sites)')
   .action(async (application, options) => {
@@ -183,6 +204,19 @@ program
       options.env && options.site
         ? [{ env: options.env, site: options.site }]
         : await getDefaultDeploySite(deployTag);
+
+    // Batch Connect AWS updates into one pipeline run per env (comma-separated sites).
+    if (application === 'connect') {
+      const sitesByEnv = sites.reduce((acc, { env, site }) => {
+        (acc[env] ??= []).push(site);
+        return acc;
+      }, {});
+      for (const [env, envSites] of Object.entries(sitesByEnv)) {
+        await deployAppWithTag('connect', env, envSites.join(','), deployTag);
+      }
+      return;
+    }
+
     for (const { env, site } of sites) {
       await deployAppWithTag(application, env, site, deployTag);
     }
@@ -223,6 +257,21 @@ program
     await deployConnect(env, site, options.liquibase, options.branch);
   });
 
+program
+  .command('deploy-connect-aws <env> <sites> <version>')
+  .description(
+    'Deploy Connect UI on AWS by updating image.tag via dp-eks-connect-ui-gitops pipeline',
+  )
+  .option('-b, --branch <branch>', 'Gitops branch to run pipeline on', 'main')
+  .option('-w, --wait', 'Wait for the pipeline to complete', true)
+  .option('--no-wait', 'Do not wait for the pipeline to complete')
+  .action(async (env, sites, version, options) => {
+    await deployConnectAws(env, sites, version, {
+      wait: options.wait,
+      branch: options.branch,
+    });
+  });
+
 program
   .command('deploy-core-pipeline <env> <site>')
   .description('Deploy Core')

package/src/next/connect-aws.js

@@ -0,0 +1,88 @@
+import { runPipeline } from './pipline.js';
+
+export const CONNECT_AWS_GITOPS_REPO = 'dp-eks-connect-ui-gitops';
+export const CONNECT_AWS_UPDATE_PIPELINE = 'update-site-image';
+export const CONNECT_AWS_DEFAULT_BRANCH = 'main';
+
+const ALLOWED_ENVS = new Set(['dev', 'qa', 'stage', 'uat', 'prod']);
+const SITE_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+const VERSION_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._+-]*$/;
+
+/**
+ * Normalize sites input to a non-empty list of site names.
+ * Accepts a single site string, comma-separated string, or string[].
+ *
+ * @param {string|string[]} sites
+ * @returns {string[]}
+ */
+export function normalizeConnectAwsSites(sites) {
+  const raw = Array.isArray(sites) ? sites : String(sites ?? '').split(',');
+  return raw.map((s) => String(s).trim()).filter(Boolean);
+}
+
+/**
+ * Trigger the Bitbucket custom pipeline that updates
+ * envs/<env>/<site>/values.yaml image.tag in dp-eks-connect-ui-gitops.
+ *
+ * @param {string} env - Target environment (dev|qa|stage|uat|prod)
+ * @param {string|string[]} sites - Site name, or comma-separated / array of sites
+ * @param {string} version - Image tag to deploy
+ * @param {{ wait?: boolean, branch?: string }} [options]
+ */
+export async function deployConnectAws(
+  env,
+  sites,
+  version,
+  { wait = true, branch = CONNECT_AWS_DEFAULT_BRANCH } = {},
+) {
+  const siteList = normalizeConnectAwsSites(sites);
+  validateConnectAwsArgs(env, siteList, version);
+
+  const siteParam = siteList.join(',');
+  console.log(
+    `Deploying AWS Connect UI: env=${env} site(s)=${siteParam} version=${version} (pipeline=${CONNECT_AWS_UPDATE_PIPELINE})`,
+  );
+
+  await runPipeline(
+    CONNECT_AWS_GITOPS_REPO,
+    CONNECT_AWS_UPDATE_PIPELINE,
+    branch,
+    {
+      ENV: env,
+      SITE: siteParam,
+      VERSION: version,
+    },
+    wait,
+  );
+}
+
+/**
+ * @param {string} env
+ * @param {string|string[]} sites - single site, comma-separated, or array
+ * @param {string} version
+ */
+export function validateConnectAwsArgs(env, sites, version) {
+  if (!ALLOWED_ENVS.has(env)) {
+    throw new Error(
+      `Invalid env "${env}". Expected one of: ${[...ALLOWED_ENVS].join(', ')}`,
+    );
+  }
+
+  const siteList = normalizeConnectAwsSites(sites);
+  if (siteList.length === 0) {
+    throw new Error('At least one site is required');
+  }
+  for (const site of siteList) {
+    if (!SITE_PATTERN.test(site)) {
+      throw new Error(`Invalid site "${site}"`);
+    }
+  }
+
+  if (!version || !VERSION_PATTERN.test(version)) {
+    throw new Error(`Invalid version "${version}"`);
+  }
+}
+
+export function isAllowedConnectAwsEnv(env) {
+  return ALLOWED_ENVS.has(env);
+}

package/src/next/connect-aws.test.js

@@ -0,0 +1,131 @@
+import { describe, expect, it, jest, beforeEach } from '@jest/globals';
+
+jest.unstable_mockModule('./pipline.js', () => ({
+  runPipeline: jest.fn(),
+}));
+
+const { runPipeline } = await import('./pipline.js');
+const {
+  deployConnectAws,
+  validateConnectAwsArgs,
+  normalizeConnectAwsSites,
+  CONNECT_AWS_GITOPS_REPO,
+  CONNECT_AWS_UPDATE_PIPELINE,
+} = await import('./connect-aws.js');
+
+describe('normalizeConnectAwsSites', () => {
+  it('accepts a single site', () => {
+    expect(normalizeConnectAwsSites('oa')).toEqual(['oa']);
+  });
+
+  it('splits comma-separated sites and trims', () => {
+    expect(normalizeConnectAwsSites('oa, athene, template')).toEqual([
+      'oa',
+      'athene',
+      'template',
+    ]);
+  });
+
+  it('accepts an array', () => {
+    expect(normalizeConnectAwsSites(['oa', 'athene'])).toEqual([
+      'oa',
+      'athene',
+    ]);
+  });
+});
+
+describe('validateConnectAwsArgs', () => {
+  it('accepts a single site', () => {
+    expect(() =>
+      validateConnectAwsArgs('qa', '1stglobal', '4.75.52'),
+    ).not.toThrow();
+  });
+
+  it('accepts comma-separated sites', () => {
+    expect(() =>
+      validateConnectAwsArgs('qa', 'oa,athene', '4.75.52'),
+    ).not.toThrow();
+  });
+
+  it('rejects invalid env', () => {
+    expect(() =>
+      validateConnectAwsArgs('preprod', '1stglobal', '4.75.52'),
+    ).toThrow(/Invalid env/);
+  });
+
+  it('rejects invalid site in a list', () => {
+    expect(() => validateConnectAwsArgs('qa', 'oa,../x', '4.75.52')).toThrow(
+      /Invalid site/,
+    );
+  });
+
+  it('rejects empty sites', () => {
+    expect(() => validateConnectAwsArgs('qa', '  ,  ', '4.75.52')).toThrow(
+      /At least one site/,
+    );
+  });
+
+  it('rejects invalid version', () => {
+    expect(() => validateConnectAwsArgs('qa', '1stglobal', '')).toThrow(
+      /Invalid version/,
+    );
+  });
+});
+
+describe('deployConnectAws', () => {
+  beforeEach(() => {
+    runPipeline.mockReset();
+    runPipeline.mockResolvedValue(undefined);
+  });
+
+  it('triggers update-site-image with a single SITE', async () => {
+    await deployConnectAws('dev', 'template', '4.76.1');
+
+    expect(runPipeline).toHaveBeenCalledWith(
+      CONNECT_AWS_GITOPS_REPO,
+      CONNECT_AWS_UPDATE_PIPELINE,
+      'main',
+      {
+        ENV: 'dev',
+        SITE: 'template',
+        VERSION: '4.76.1',
+      },
+      true,
+    );
+  });
+
+  it('passes comma-separated SITE for multiple sites', async () => {
+    await deployConnectAws('qa', ['oa', 'athene'], '4.76.1');
+
+    expect(runPipeline).toHaveBeenCalledWith(
+      CONNECT_AWS_GITOPS_REPO,
+      CONNECT_AWS_UPDATE_PIPELINE,
+      'main',
+      {
+        ENV: 'qa',
+        SITE: 'oa,athene',
+        VERSION: '4.76.1',
+      },
+      true,
+    );
+  });
+
+  it('honors wait and branch options', async () => {
+    await deployConnectAws('stage', 'oa,athene', 'git-commit-abc123', {
+      wait: false,
+      branch: 'feature/update-site-image-pipeline',
+    });
+
+    expect(runPipeline).toHaveBeenCalledWith(
+      CONNECT_AWS_GITOPS_REPO,
+      CONNECT_AWS_UPDATE_PIPELINE,
+      'feature/update-site-image-pipeline',
+      {
+        ENV: 'stage',
+        SITE: 'oa,athene',
+        VERSION: 'git-commit-abc123',
+      },
+      false,
+    );
+  });
+});

package/src/next/deploy.js

@@ -17,6 +17,11 @@ import { gitDescribeToSemver } from './git-to-semver.js';
 import { deployConnect, deployCore } from './jenkins.js';
 import { makeJiraRequest } from './jira.js';
 import { autoDeployConfigName } from './config.js';
+import {
+  CONNECT_AWS_GITOPS_REPO,
+  deployConnectAws,
+  isAllowedConnectAwsEnv,
+} from './connect-aws.js';
 
 /**
  * Clone the repository, read the YAML file, and return the parsed data and file paths.
@@ -432,6 +437,14 @@ export async function deployTemplate(
 export async function deployAppWithTag(application, env, site, deployTag) {
   console.log(`Deploying application: ${application} for site: ${site}`);
   console.log(`Using deployment tag: ${deployTag}`);
+
+  // Connect UI on AWS: update dp-eks-connect-ui-gitops image.tag via Bitbucket pipeline.
+  // (Not a Next gitops-<env> app — no <app>.values.yaml under dp/<site>/.)
+  if (application === 'connect') {
+    await deployConnectAws(env, site, deployTag, { wait: true });
+    return;
+  }
+
   const appDetails = appInfo[application] ?? getDefaultAppInfo(application);
   if (!appInfo[application]) {
     console.log(
@@ -847,10 +860,17 @@ export async function updateSiteVersion(
   standardConfig,
   siteConfig,
   jiraTicket,
+  connectVersion,
 ) {
-  if (!uiVersion && !graphVersion && !standardConfig && !siteConfig) {
+  if (
+    !uiVersion &&
+    !graphVersion &&
+    !standardConfig &&
+    !siteConfig &&
+    !connectVersion
+  ) {
     console.error(
-      '❌ At least one of --ui-version, --graph-version, --standard-config, or --site-config must be provided',
+      '❌ At least one of --ui-version, --graph-version, --standard-config, --site-config, or --connect-version must be provided',
     );
     process.exit(1);
   }
@@ -944,6 +964,15 @@ export async function updateSiteVersion(
     }
   }
 
+  const hasNextVersionUpdate =
+    uiVersion || graphVersion || standardConfig || siteConfig;
+
+  // Connect AWS-only: update image.tag via gitops pipeline and return.
+  if (connectVersion && !hasNextVersionUpdate) {
+    await deployConnectAws(env, site, connectVersion, { wait: true });
+    return;
+  }
+
   const toRepoPath = await cloneEnvRepository(env);
 
   if (env !== 'dev') {
@@ -1089,6 +1118,44 @@ export async function updateSiteVersion(
   } else {
     console.log('No changes detected. Nothing to push.');
   }
+
+  if (connectVersion) {
+    await deployConnectAws(env, site, connectVersion, { wait: true });
+  }
+}
+
+/**
+ * Read dp-connect-ui.image.tag for a site from the AWS Connect gitops repo.
+ * @param {string} env
+ * @param {string} site
+ * @returns {Promise<string>}
+ */
+export async function getConnectAwsImageTag(env, site) {
+  if (!isAllowedConnectAwsEnv(env)) {
+    throw new Error(
+      `Invalid AWS Connect env "${env}". Expected one of: dev, qa, stage, uat, prod`,
+    );
+  }
+
+  const repoPath = await cloneRepository(CONNECT_AWS_GITOPS_REPO);
+  const valuesFile = path.join(repoPath, 'envs', env, site, 'values.yaml');
+
+  try {
+    if (!fs.existsSync(valuesFile)) {
+      throw new Error(`AWS Connect values file not found: ${valuesFile}`);
+    }
+
+    const content = fs.readFileSync(valuesFile, 'utf8');
+    const match = content.match(/^\s{4}tag:\s*"?([^"\n]+)"?\s*$/m);
+    if (!match?.[1]) {
+      throw new Error(
+        `Could not parse image.tag from envs/${env}/${site}/values.yaml`,
+      );
+    }
+    return match[1].trim();
+  } finally {
+    await $`rm -rf ${repoPath}`;
+  }
 }
 
 export async function deployFromSite(
@@ -1099,6 +1166,7 @@ export async function deployFromSite(
   isDeployCore,
   isDeployConnect,
   jiraTicket,
+  isDeployConnectAws = 'false',
 ) {
   console.log(
     `Deploying changes from ${fromSite} in ${fromEnv} to ${toSite} in ${toEnv}${jiraTicket ? ` approved by JIRA ticket ${jiraTicket}` : ''}`,
@@ -1236,6 +1304,31 @@ export async function deployFromSite(
     }
   }
 
+  if (isDeployConnectAws === 'true') {
+    const sourceVersion = await getConnectAwsImageTag(fromEnv, fromSite);
+    let targetVersion;
+    try {
+      targetVersion = await getConnectAwsImageTag(toEnv, toSite);
+    } catch (error) {
+      console.warn(
+        `Could not read target AWS Connect version (${error.message}); deploying source version anyway.`,
+      );
+      targetVersion = null;
+    }
+
+    if (targetVersion && targetVersion === sourceVersion) {
+      console.log(
+        `AWS Connect versions already match (${sourceVersion}); skipping deploy-connect-aws.`,
+      );
+    } else {
+      console.log(
+        `AWS Connect version to deploy: ${sourceVersion}` +
+          (targetVersion ? ` (target currently ${targetVersion})` : ''),
+      );
+      await deployConnectAws(toEnv, toSite, sourceVersion, { wait: true });
+    }
+  }
+
   // Clone repositories for source and target environments
   const fromRepoPath = await cloneEnvRepository(fromEnv);
   const toRepoPath =

package/.gitignore

@@ -1,109 +0,0 @@
-# See https://help.github.com/articles/ignoring-files/ for more about ignoring files.
-
-# IDE
-.idea
-*.iml
-# Dependencies
-/node_modules
-/.pnp
-.pnp.js
-
-# Testing
-/coverage
-
-# Next.js
-/.next/
-/out/
-
-# Production
-/build
-/dist
-
-# Misc
-.DS_Store
-*.pem
-cypress/screenshots/
-
-# Debug
-npm-debug.log*
-yarn-debug.log*
-yarn-error.log*
-
-# Local env files
-.env
-.env*.local
-
-# Vercel
-.vercel
-
-# Typescript
-*.tsbuildinfo
-next-env.d.ts
-
-
-# Logs
-logs
-*.log
-
-# Runtime data
-pids
-*.pid
-*.seed
-
-# Directory for instrumented libs generated by jscoverage/JSCover
-lib-cov
-
-# Coverage directory used by tools like istanbul
-coverage
-
-# nyc test coverage
-.nyc_output
-
-# Grunt intermediate storage (http://gruntjs.com/creating-plugins#storing-task-files)
-.grunt
-
-# node-waf configuration
-.lock-wscript
-
-# Compiled binary addons (http://nodejs.org/api/addons.html)
-build/Release
-
-# Dependency directories
-node_modules
-jspm_packages
-
-# Optional npm cache directory
-.npm
-
-# Optional REPL history
-.node_repl_history
-.next
-
-scratch
-
-# visual studio code
-.vscode/
-
-src/gql/graphql.js
-.yalc/
-yalc.lock
-
-.last-run.json
-
-test-results
-coverage-reports
-.sonar
-.v8-coverage
-/assets
-tests/lib/data/auth.json
-
-failed-tests.json
-
-/tmp
-
-.claude
-.claude/settings.local.json
-
-.run
-
-.pnpm-store