@docupace/pipeline 1.0.66 → 1.0.68

package/bitbucket-pipelines.yml

@@ -1,3 +1,4 @@
+# bitbucket-pipelines.yml
 clone:
   depth: 2
 
@@ -6,23 +7,54 @@ pipelines:
     '**':
       - step:
           runs-on:
+            - self.hosted
             - linux.shell
-            - onprem
           name: On Pull Request
           script:
+            - npm install -g pnpm
             - pnpm config set //registry.npmjs.org/:_authToken $DOCUPACE_NPM_TOKEN
             - pnpm install --frozen-lockfile
-            - >
-              npx eslint . --rule "no-unused-vars: warn" --rule "no-useless-escape: warn" --color
+            - 'npx eslint . --rule "no-unused-vars: warn" --rule "no-useless-escape: warn" --color'
+            - pnpm test
+          artifacts:
+            - coverage/**
+          after-script:
+            - echo "Pipeline completed with status $BITBUCKET_EXIT_CODE"
+
   custom:
     scheduled-tests:
       - step:
           runs-on:
+            - self.hosted
             - linux.shell
-            - onprem
-          name: Manual
+          name: Scheduled Tests
           script:
+            - npm install -g pnpm
             - pnpm config set //registry.npmjs.org/:_authToken $DOCUPACE_NPM_TOKEN
             - pnpm install --frozen-lockfile
-            - >
-              npx eslint . --rule "no-unused-vars: warn" --rule "no-useless-escape: warn" --color
+            - 'npx eslint . --rule "no-unused-vars: warn" --rule "no-useless-escape: warn" --color'
+            - pnpm test
+          artifacts:
+            - coverage/**
+          after-script:
+            - echo "Pipeline completed with status $BITBUCKET_EXIT_CODE"
+
+  branches:
+    main:
+      - step:
+          runs-on:
+            - self.hosted
+            - linux.shell
+          name: Main Branch Build
+          script:
+            - npm install -g pnpm
+            - pnpm config set //registry.npmjs.org/:_authToken $DOCUPACE_NPM_TOKEN
+            - pnpm install --frozen-lockfile
+            - 'npx eslint . --rule "no-unused-vars: warn" --rule "no-useless-escape: warn" --color'
+            - pnpm test
+          artifacts:
+            - coverage/**
+
+definitions:
+  caches:
+    pnpm: ~/.pnpm-store

package/eslint.config.js

@@ -4,17 +4,29 @@ import prettierConfig from 'eslint-config-prettier';
 import prettierPlugin from 'eslint-plugin-prettier';
 import importPlugin from 'eslint-plugin-import';
 
-/** @type {import('eslint').Linter.Config[]} */
 export default [
   {
     languageOptions: {
       globals: {
         ...globals.browser,
-        ...globals.node, // Add Node.js globals
+        ...globals.node,
       },
     },
   },
+
+  // Core JS rules
   pluginJs.configs.recommended,
+
+  // Jest globals for test files only
+  {
+    files: ['**/*.test.js', '**/__tests__/**/*.js'],
+    languageOptions: {
+      globals: {
+        ...globals.jest,
+      },
+    },
+  },
+
   {
     plugins: {
       prettier: prettierPlugin,
@@ -29,7 +41,6 @@ export default [
     rules: {
       ...prettierConfig.rules,
       'prettier/prettier': 'error',
-      // Import-related rules
       'import/no-unresolved': 'error',
       'import/named': 'error',
       'import/no-extraneous-dependencies': 'error',

package/jest.config.js

@@ -0,0 +1,15 @@
+// jest.config.js
+export default {
+  testEnvironment: 'node',
+  transform: {},
+  verbose: true,
+  collectCoverage: true,
+  coverageDirectory: 'coverage',
+  coverageReporters: ['text', 'lcov', 'json', 'html'],
+  collectCoverageFrom: [
+    'src/**/*.{js,ts}',
+    '!src/**/cli.js',
+    '!src/**/*.test.{js,ts}',
+    '!**/node_modules/**',
+  ],
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@docupace/pipeline",
-  "version": "1.0.66",
+  "version": "1.0.68",
   "main": "index.js",
   "type": "module",
   "bin": {
@@ -18,6 +18,7 @@
     "@changesets/cli": "^2.27.10",
     "@docupace/core-client": "^0.1.94",
     "@docupace/pipeline": "^1.0.33-alpha-2",
+    "@jest/globals": "^30.1.2",
     "auth0-deploy-cli": "^8.8.0",
     "axios": "^1.7.9",
     "commander": "^12.1.0",
@@ -41,9 +42,11 @@
     "eslint-import-resolver-typescript": "^4.4.4",
     "eslint-plugin-prettier": "^5.2.1",
     "globals": "^15.14.0",
+    "jest": "^30.1.3",
     "prettier": "^3.4.2"
   },
   "scripts": {
+    "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js --coverage --testPathIgnorePatterns='src/next/test\\.js'",
     "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",
     "test-run-pipline": "dp-next-cli run-pipeline -r docupace-next-e2e -b master -p run-tests-qa",

package/src/auth0/alias.js

@@ -1,13 +1,8 @@
 import axios from 'axios';
-
 import { createAlias } from '../next/alias.js';
-
 import { getAuth0AuthToken } from './configure.js';
-
 import { getVaultSecrets } from './vault.js';
-
 import { getVaultSecretsConfigs } from '../next/config.js';
-
 import { cloneEnvRepository, readDeployConfig } from '../next/deploy.js';
 
 export async function getCCAlias({ application, auth0Domain, auth0AuthToken }) {
@@ -35,7 +30,14 @@ export async function getCCAlias({ application, auth0Domain, auth0AuthToken }) {
   }
 }
 
-export async function configureAlias(site, env, username, password, realm) {
+export async function configureAlias(
+  site,
+  env,
+  username,
+  password,
+  realm,
+  auth0Tenant,
+) {
   console.log(`Creating alias for site: ${site} in env: ${env}`);
   // Site Common Secrets
   const siteCommonSecretsPath =
@@ -43,7 +45,12 @@ export async function configureAlias(site, env, username, password, realm) {
   console.log(`siteCommonSecretsPath => ${siteCommonSecretsPath}`);
   const siteCommonSecrets = await getVaultSecrets(siteCommonSecretsPath);
 
-  const auth0Domain = `docupace-${env}-${site}.us.auth0.com`;
+  let auth0Domain;
+  if (auth0Tenant === '') {
+    auth0Domain = `docupace-${env}-${site}.us.auth0.com`;
+  } else {
+    auth0Domain = `${auth0Tenant}.us.auth0.com`;
+  }
   const auth0ClientId = siteCommonSecrets.AUTH0_CLIENT_ID;
   const auth0ClientSecret = siteCommonSecrets.AUTH0_CLIENT_SECRET;
   const auth0Token = await getAuth0AuthToken(

package/src/auth0/alias.test.js

@@ -0,0 +1,172 @@
+// alias.test.js
+import { jest } from '@jest/globals';
+
+// --------- ESM-Compatible Mocks ---------
+jest.unstable_mockModule('axios', () => ({
+  default: {
+    get: jest.fn(),
+  },
+}));
+
+jest.unstable_mockModule('../next/alias.js', () => ({
+  createAlias: jest.fn(),
+}));
+
+jest.unstable_mockModule('./configure.js', () => ({
+  getAuth0AuthToken: jest.fn(),
+}));
+
+jest.unstable_mockModule('./vault.js', () => ({
+  getVaultSecrets: jest.fn(),
+}));
+
+jest.unstable_mockModule('../next/config.js', () => ({
+  getVaultSecretsConfigs: jest.fn(),
+}));
+
+jest.unstable_mockModule('../next/deploy.js', () => ({
+  cloneEnvRepository: jest.fn(),
+  readDeployConfig: jest.fn(),
+}));
+
+// --------- Import AFTER mocks ---------
+const { configureAlias, getCCAlias } = await import('./alias.js');
+const axios = (await import('axios')).default;
+const { createAlias } = await import('../next/alias.js');
+const { getAuth0AuthToken } = await import('./configure.js');
+const { getVaultSecrets } = await import('./vault.js');
+const { getVaultSecretsConfigs } = await import('../next/config.js');
+const { cloneEnvRepository, readDeployConfig } = await import(
+  '../next/deploy.js'
+);
+
+// --------- Shared Test Setup ---------
+beforeAll(() => {
+  jest.spyOn(console, 'log').mockImplementation(() => {}); // silence logs
+});
+
+afterAll(() => {
+  console.log.mockRestore();
+});
+
+describe('configureAlias', () => {
+  const site = 'example';
+  const env = 'dev';
+  const username = 'admin';
+  const password = 'pass';
+  const realm = 'Users';
+  const auth0Tenant = '';
+
+  const mockSecrets = {
+    AUTH0_CLIENT_ID: 'client-id',
+    AUTH0_CLIENT_SECRET: 'client-secret',
+  };
+
+  const mockToken = 'mocked-auth0-token';
+
+  const mockClients = [
+    { name: 'docupace-graphql-client-credentials', client_id: 'client-123' },
+  ];
+
+  const mockConfig = {
+    deployConfig: {
+      graphqlServer: {
+        coreUrl: 'https://core.example.com',
+      },
+    },
+  };
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+
+    getVaultSecretsConfigs.mockReturnValue({
+      siteCommonSecretsPath: 'vault/path/to/secrets',
+    });
+
+    getVaultSecrets.mockResolvedValue(mockSecrets);
+    getAuth0AuthToken.mockResolvedValue(mockToken);
+    axios.get.mockResolvedValue({ data: mockClients });
+    cloneEnvRepository.mockResolvedValue(undefined);
+    readDeployConfig.mockResolvedValue(mockConfig);
+    createAlias.mockResolvedValue(undefined);
+  });
+
+  it('should configure alias with default tenant and call all required steps', async () => {
+    await configureAlias(site, env, username, password, realm, auth0Tenant);
+
+    expect(getVaultSecretsConfigs).toHaveBeenCalledWith(site);
+    expect(getVaultSecrets).toHaveBeenCalledWith('vault/path/to/secrets');
+
+    expect(getAuth0AuthToken).toHaveBeenCalledWith(
+      'docupace-dev-example.us.auth0.com',
+      'client-id',
+      'client-secret',
+    );
+
+    expect(cloneEnvRepository).toHaveBeenCalledWith(env);
+
+    expect(readDeployConfig).toHaveBeenCalledWith(
+      'graphql-server',
+      env,
+      site,
+      'values',
+    );
+
+    expect(axios.get).toHaveBeenCalledWith(
+      'https://docupace-dev-example.us.auth0.com/api/v2/clients',
+      { headers: { authorization: `Bearer ${mockToken}` } },
+    );
+
+    expect(createAlias).toHaveBeenCalledWith(
+      'https://core.example.com',
+      username,
+      password,
+      realm,
+      'client-123@clients',
+    );
+  });
+});
+
+describe('getCCAlias', () => {
+  const application = 'docupace-graphql-client-credentials';
+  const auth0Domain = 'example.auth0.com';
+  const auth0AuthToken = 'token';
+
+  it('should return correct alias string for client', async () => {
+    axios.get.mockResolvedValue({
+      data: [{ name: application, client_id: 'abc123' }],
+    });
+
+    const alias = await getCCAlias({
+      application,
+      auth0Domain,
+      auth0AuthToken,
+    });
+    expect(alias).toBe('abc123@clients');
+
+    expect(axios.get).toHaveBeenCalledWith(
+      'https://example.auth0.com/api/v2/clients',
+      { headers: { authorization: 'Bearer token' } },
+    );
+  });
+
+  it('should log error and return undefined if axios fails', async () => {
+    axios.get.mockRejectedValue(new Error('Network error'));
+    const errorSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
+
+    const result = await getCCAlias({
+      application,
+      auth0Domain,
+      auth0AuthToken,
+    });
+    expect(result).toBeUndefined();
+
+    expect(errorSpy).toHaveBeenCalledWith(
+      expect.stringContaining(
+        'Failed to form alias name for application: docupace-graphql-client-credentials: Network error',
+      ),
+    );
+
+    errorSpy.mockRestore();
+  });
+});

package/src/auth0/cli.js

@@ -57,24 +57,26 @@ program
   });
 
 program
-  .command('configureAlias <site> <env> <username> <password> <realm>')
+  .command(
+    'configureAlias <site> <env> <username> <password> <realm> [auth0Tenant]',
+  )
   .description('Configure Core Alias for the given site')
-  .action(async (site, env, username, password, realm) => {
-    await configureAlias(site, env, username, password, realm);
+  .action(async (site, env, username, password, realm, auth0Tenant = '') => {
+    await configureAlias(site, env, username, password, realm, auth0Tenant);
   });
 
 program
-  .command('exportConf <site> <env>')
+  .command('exportConf <site> <env> [auth0Tenant]')
   .description('Export Auth0 configuration for the given site')
-  .action(async (site, env) => {
-    await exportConf(site, env);
+  .action(async (site, env, auth0Tenant = '') => {
+    await exportConf(site, env, auth0Tenant);
   });
 
 program
-  .command('getAuth0Metadata <site> <env>')
+  .command('getAuth0Metadata <site> <env> [auth0Tenant]')
   .description('Get Auth0 metadata for the given site')
-  .action(async (site, env) => {
-    await getAuth0Metadata(site, env);
+  .action(async (site, env, auth0Tenant = '') => {
+    await getAuth0Metadata(site, env, auth0Tenant);
   });
 
 program.parse(process.argv);

package/src/auth0/configure.js

@@ -1,7 +1,7 @@
 import fs from 'fs-extra';
 import path from 'path';
 import axios from 'axios';
-import crypto from 'crypto';
+import * as crypto from 'crypto';
 
 import {
   cloneEnvRepository,
@@ -11,6 +11,7 @@ import {
 } from '../next/deploy.js';
 
 import { getVaultSecrets, updateVaultSecrets } from './vault.js';
+
 import {
   coreSiteEnvMap,
   environmentConfig,

package/src/auth0/configure.test.js

@@ -0,0 +1,167 @@
+// @jest-environment node
+import { jest } from '@jest/globals';
+
+// ─── Mock All Required Modules ───────────────────────────────────────────────
+
+jest.unstable_mockModule('fs-extra', () => ({
+  default: {
+    promises: {
+      mkdir: jest.fn(),
+    },
+    writeFile: jest.fn(),
+    ensureDir: jest.fn(),
+  },
+  writeFile: jest.fn(),
+  ensureDir: jest.fn(),
+}));
+
+jest.unstable_mockModule('axios', () => ({
+  default: {
+    post: jest.fn(),
+    get: jest.fn(),
+  },
+}));
+
+jest.unstable_mockModule('crypto', () => ({
+  randomBytes: () => ({
+    toString: () => 'mockBase64==',
+  }),
+}));
+
+jest.unstable_mockModule('../next/deploy.js', () => ({
+  cloneRepository: jest.fn(),
+  cloneEnvRepository: jest.fn(),
+  pushDeployConfig: jest.fn(),
+  readDeployConfig: jest.fn(),
+}));
+
+jest.unstable_mockModule('./vault.js', () => ({
+  getVaultSecrets: jest.fn(),
+  updateVaultSecrets: jest.fn(),
+}));
+
+jest.unstable_mockModule('../next/config.js', () => ({
+  coreSiteEnvMap: { dev: 'dev-env' },
+  environmentConfig: {
+    dev: {
+      newUrl: (site) => `dev.${site}.com`,
+      oldUrl: (site) => `legacy.${site}.com`,
+      ccUrl: (site) => `cc.${site}.com`,
+      docupaceHost: () => 'docupace.com',
+    },
+  },
+  getVaultSecretsConfigs: jest.fn(),
+}));
+
+// ─── Global References ───────────────────────────────────────────────────────
+
+let fs, axios, deploy, vault, config;
+let getAuth0AuthToken, cleanAndWritePropertiesFile, updateCoreSiteConfig;
+
+const originalProcessExit = process.exit;
+
+beforeAll(async () => {
+  // Mock process.exit to prevent killing the test runner
+  process.exit = jest.fn();
+
+  // Suppress noisy error output
+  jest.spyOn(console, 'error').mockImplementation(() => {});
+  jest.spyOn(console, 'log').mockImplementation(() => {});
+
+  // Import after mocks
+  ({ default: fs } = await import('fs-extra'));
+  ({ default: axios } = await import('axios'));
+  deploy = await import('../next/deploy.js');
+  vault = await import('./vault.js');
+  config = await import('../next/config.js');
+
+  const mod = await import('./configure.js');
+  ({ getAuth0AuthToken, cleanAndWritePropertiesFile, updateCoreSiteConfig } =
+    mod);
+});
+
+afterAll(() => {
+  // Restore
+  process.exit = originalProcessExit;
+  console.error.mockRestore();
+  console.log.mockRestore();
+});
+
+// ─── Tests ───────────────────────────────────────────────────────────────────
+
+describe('Deployment Automation Module (ESM)', () => {
+  describe('getAuth0AuthToken', () => {
+    it('should return access token on success', async () => {
+      axios.post.mockResolvedValue({ data: { access_token: 'mock-token' } });
+      const token = await getAuth0AuthToken('auth.domain', 'cid', 'secret');
+      expect(token).toBe('mock-token');
+    });
+
+    it('should return undefined on failure', async () => {
+      axios.post.mockRejectedValue({ message: 'fail' });
+      const token = await getAuth0AuthToken('auth.domain', 'cid', 'secret');
+      expect(token).toBeUndefined();
+      expect(console.error).toHaveBeenCalledWith(
+        'Error fetching Auth0 token:',
+        'fail',
+      );
+    });
+  });
+
+  describe('cleanAndWritePropertiesFile', () => {
+    it('writes cleaned file content', async () => {
+      fs.writeFile.mockResolvedValue();
+      await cleanAndWritePropertiesFile('/tmp/test.properties', 'a=1\n\nb=2\n');
+      expect(fs.writeFile).toHaveBeenCalledWith(
+        '/tmp/test.properties',
+        'a=1\nb=2',
+        'utf8',
+      );
+    });
+
+    it('calls process.exit on write error', async () => {
+      fs.writeFile.mockRejectedValue(new Error('disk full'));
+      await cleanAndWritePropertiesFile('/bad/path', 'x=y');
+      expect(process.exit).toHaveBeenCalledWith(1);
+    });
+  });
+
+  describe('updateCoreSiteConfig', () => {
+    it('updates config when S3 is enabled', async () => {
+      config.getVaultSecretsConfigs.mockReturnValue({
+        awsSecretsPath: 'aws/path',
+      });
+
+      deploy.cloneRepository.mockResolvedValue('/repo/path');
+
+      vault.getVaultSecrets.mockResolvedValue({
+        AWS_ACCESS_KEY_ID: 'abc',
+        AWS_SECRET_ACCESS_KEY: 'def',
+        AWS_REGION: 'us-west-2',
+      });
+
+      fs.ensureDir.mockResolvedValue();
+      fs.writeFile.mockResolvedValue();
+      deploy.pushDeployConfig.mockResolvedValue();
+
+      await updateCoreSiteConfig('mysite', 'dev', true, false);
+
+      expect(fs.ensureDir).toHaveBeenCalledWith('/repo/path/MYSITE');
+      expect(fs.writeFile).toHaveBeenCalled();
+      expect(deploy.pushDeployConfig).toHaveBeenCalled();
+    });
+
+    it('calls process.exit if cloneRepository fails', async () => {
+      config.getVaultSecretsConfigs.mockReturnValue({
+        awsSecretsPath: 'aws/path',
+      });
+
+      deploy.cloneRepository.mockRejectedValue(new Error('bad clone'));
+
+      await updateCoreSiteConfig('mysite', 'dev', true, false);
+
+      expect(process.exit).toHaveBeenCalledWith(1);
+      expect(console.error).toHaveBeenCalledWith('Error:', 'bad clone');
+    });
+  });
+});

package/src/auth0/export.js

@@ -2,7 +2,7 @@ import { getVaultSecrets } from './vault.js';
 import { getVaultSecretsConfigs } from '../next/config.js';
 import { dump } from 'auth0-deploy-cli';
 
-export async function exportConf(site, env) {
+export async function exportConf(site, env, auth0Tenant) {
   try {
     console.log(
       `Exporting Auth0 configuration for site: ${site} and env: ${env}`,
@@ -13,7 +13,12 @@ export async function exportConf(site, env) {
     console.log(`siteCommonSecretsPath => ${siteCommonSecretsPath}`);
     const siteCommonSecrets = await getVaultSecrets(siteCommonSecretsPath);
 
-    const auth0Domain = `docupace-${env}-${site}.us.auth0.com`;
+    let auth0Domain;
+    if (auth0Tenant === '') {
+      auth0Domain = `docupace-${env}-${site}.us.auth0.com`;
+    } else {
+      auth0Domain = `${auth0Tenant}.us.auth0.com`;
+    }
     const auth0ClientId = siteCommonSecrets.AUTH0_CLIENT_ID;
     const auth0ClientSecret = siteCommonSecrets.AUTH0_CLIENT_SECRET;