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

package/src/auth0/vault.js

@@ -0,0 +1,60 @@
+// src/auth0/vault.js
+import axios from 'axios';
+
+export async function getVaultSecrets(vaultPath) {
+  if (!vaultPath) throw new Error('VAULT_PATH is required.');
+
+  const token = process.env.VAULT_TOKEN;
+  const addr = process.env.VAULT_ADDR;
+  if (!token || !addr)
+    throw new Error('VAULT_TOKEN and VAULT_ADDR must be set.');
+
+  if (process.env.VAULT_SKIP_VERIFY === 'true') {
+    process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
+  }
+
+  try {
+    const response = await axios.get(`${addr}/v1/${vaultPath}`, {
+      headers: { 'X-Vault-Token': token },
+    });
+
+    const data = response.data;
+    if (data && typeof data === 'object') return data.data.data;
+    throw new Error('Invalid JSON received from Vault.');
+  } catch (err) {
+    console.error(
+      'Vault GET error:',
+      err?.message || err?.response?.statusText || err,
+    );
+  }
+}
+
+export async function updateVaultSecrets(vaultPath, secretData) {
+  if (!vaultPath || !secretData)
+    throw new Error('Both vaultPath and secretData are required.');
+
+  const token = process.env.VAULT_TOKEN;
+  const addr = process.env.VAULT_ADDR;
+  if (!token || !addr)
+    throw new Error('VAULT_TOKEN and VAULT_ADDR must be set.');
+
+  if (process.env.VAULT_SKIP_VERIFY === 'true') {
+    process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
+  }
+
+  try {
+    const response = await axios.post(`${addr}/v1/${vaultPath}`, secretData, {
+      headers: {
+        'X-Vault-Token': token,
+        'Content-Type': 'application/json',
+      },
+    });
+
+    return response.data;
+  } catch (err) {
+    console.error(
+      'Vault POST error:',
+      err?.message || err?.response?.statusText || err,
+    );
+  }
+}

package/src/auth0/vault.test.js

@@ -0,0 +1,134 @@
+// src/auth0/vault.test.js
+import { jest } from '@jest/globals';
+
+// ESM-compatible mocking
+jest.unstable_mockModule('axios', () => ({
+  default: {
+    get: jest.fn(),
+    post: jest.fn(),
+  },
+}));
+
+describe('Vault Utilities', () => {
+  let axios;
+  let getVaultSecrets;
+  let updateVaultSecrets;
+  const OLD_ENV = process.env;
+
+  beforeAll(async () => {
+    // Dynamic import AFTER mocking
+    axios = (await import('axios')).default;
+    const vault = await import('./vault.js');
+    getVaultSecrets = vault.getVaultSecrets;
+    updateVaultSecrets = vault.updateVaultSecrets;
+  });
+
+  beforeEach(() => {
+    jest.resetModules();
+    process.env = { ...OLD_ENV };
+    jest.clearAllMocks();
+  });
+
+  afterAll(() => {
+    process.env = OLD_ENV;
+  });
+
+  describe('getVaultSecrets', () => {
+    it('should fetch secrets from Vault successfully', async () => {
+      process.env.VAULT_TOKEN = 'test-token';
+      process.env.VAULT_ADDR = 'https://vault.example.com';
+
+      axios.get.mockResolvedValueOnce({
+        data: {
+          data: {
+            data: {
+              username: 'admin',
+              password: 'secret',
+            },
+          },
+        },
+      });
+
+      const result = await getVaultSecrets('secret/data/myapp');
+      expect(result).toEqual({ username: 'admin', password: 'secret' });
+    });
+
+    it('should throw error if vaultPath is missing', async () => {
+      await expect(getVaultSecrets()).rejects.toThrow(
+        'VAULT_PATH is required.',
+      );
+    });
+
+    it('should throw error if env vars are missing', async () => {
+      delete process.env.VAULT_TOKEN;
+      delete process.env.VAULT_ADDR;
+
+      await expect(getVaultSecrets('secret/data/myapp')).rejects.toThrow(
+        'VAULT_TOKEN and VAULT_ADDR must be set.',
+      );
+    });
+
+    it('should handle Vault error response', async () => {
+      process.env.VAULT_TOKEN = 'token';
+      process.env.VAULT_ADDR = 'https://vault.example.com';
+
+      axios.get.mockRejectedValueOnce({
+        response: { status: 403, statusText: 'Forbidden' },
+      });
+
+      const result = await getVaultSecrets('secret/data/myapp');
+      expect(result).toBeUndefined();
+    });
+  });
+
+  describe('updateVaultSecrets', () => {
+    it('should update secrets in Vault successfully', async () => {
+      process.env.VAULT_TOKEN = 'test-token';
+      process.env.VAULT_ADDR = 'https://vault.example.com';
+
+      const secretData = {
+        data: {
+          apiKey: '123456',
+        },
+      };
+
+      axios.post.mockResolvedValueOnce({
+        data: {
+          success: true,
+        },
+      });
+
+      const result = await updateVaultSecrets('secret/data/myapp', secretData);
+      expect(result).toEqual({ success: true });
+    });
+
+    it('should throw error if vaultPath or secretData is missing', async () => {
+      await expect(updateVaultSecrets()).rejects.toThrow(
+        'Both vaultPath and secretData are required.',
+      );
+    });
+
+    it('should throw error if env vars are missing', async () => {
+      delete process.env.VAULT_TOKEN;
+      delete process.env.VAULT_ADDR;
+
+      await expect(updateVaultSecrets('secret/data/myapp', {})).rejects.toThrow(
+        'VAULT_TOKEN and VAULT_ADDR must be set.',
+      );
+    });
+
+    it('should handle Vault error response', async () => {
+      process.env.VAULT_TOKEN = 'token';
+      process.env.VAULT_ADDR = 'https://vault.example.com';
+
+      axios.post.mockRejectedValueOnce({
+        response: { status: 500, statusText: 'Internal Server Error' },
+      });
+
+      const result = await updateVaultSecrets('secret/data/myapp', {
+        data: {},
+      });
+      expect(result).toBeUndefined();
+    });
+  });
+});

package/src/changeset/changelog-wiki.js

@@ -0,0 +1,328 @@
+// npm i axios
+import axios from 'axios';
+import { readFileSync } from 'fs';
+import { getPackageNames } from './package-util.js';
+import path from 'path';
+import { toShortVersion } from './version.js';
+
+/**
+ * Required env:
+ *   CONFLUENCE_BASE_URL   e.g. "https://docupacellc.atlassian.net/wiki"
+ *   CONFLUENCE_EMAIL      e.g. "you@docupace.com"
+ *   CONFLUENCE_API_TOKEN  Atlassian API token
+ */
+const BASE_URL = process.env.CONFLUENCE_BASE_URL;
+const EMAIL = process.env.CONFLUENCE_EMAIL;
+const API_TOKEN = process.env.CONFLUENCE_API_TOKEN;
+
+const getHttpService = () =>
+  axios.create({
+    baseURL: BASE_URL.replace(/\/+$/, ''),
+    auth: { username: EMAIL, password: API_TOKEN },
+  });
+
+/** ---------- ADF builder: Markdown macro ---------- */
+function adfMarkdown(markdown) {
+  return {
+    type: 'doc',
+    version: 1,
+    content: [
+      {
+        type: 'extension',
+        attrs: {
+          layout: 'default',
+          extensionType: 'com.atlassian.confluence.macro.core',
+          extensionKey: 'markdown',
+          parameters: {
+            macroParams: {
+              sourceType: { value: 'MacroBody' },
+              darkmode: { value: 'auto' },
+              syntax: { value: 'Markdown' },
+              attachmentPageId: { value: '' },
+              attachmentId: { value: '' },
+              url: { value: '' },
+              __bodyContent: { value: markdown },
+            },
+          },
+        },
+      },
+    ],
+  };
+}
+
+/** ---------- API helpers (v2) ---------- */
+
+// get a page (v2) by id
+async function getPage(pageId) {
+  const { data } = await getHttpService().get(`/api/v2/pages/${pageId}`);
+  return data;
+}
+
+// list child pages (paginated) and return *all* children
+async function listChildPages(parentId) {
+  const all = [];
+  let next = `/api/v2/pages/${parentId}/children?limit=200`;
+
+  while (next) {
+    const { data } = await getHttpService().get(next);
+    if (Array.isArray(data.results)) all.push(...data.results);
+    next = data?._links?.next || null;
+  }
+  return all;
+}
+
+// find a direct child page by exact title
+async function findChildByTitle(parentId, title) {
+  const kids = await listChildPages(parentId);
+  return kids.find((p) => (p.title || '').trim() === title.trim()) || null;
+}
+
+// create a child page under a parent
+async function createChildPage({
+  parentId,
+  spaceId,
+  title,
+  adf,
+  message = 'Create via API',
+}) {
+  const payload = {
+    status: 'current',
+    title,
+    spaceId,
+    parentId,
+    body: {
+      atlas_doc_format: {
+        value: adf,
+        representation: 'atlas_doc_format',
+      },
+    },
+    version: { number: 1, message, minorEdit: false },
+  };
+  const { data } = await getHttpService().post(`/api/v2/pages`, payload);
+  return data;
+}
+
+// update an existing page (replace body + optionally title)
+async function updatePage({
+  page,
+  title = page.title,
+  adf,
+  message = 'Update via API',
+}) {
+  if (!page.version) {
+    page = await getPage(page.id);
+  }
+  const payload = {
+    id: page.id,
+    status: 'current',
+    title,
+    spaceId: page.spaceId,
+    body: {
+      atlas_doc_format: {
+        value: adf,
+        representation: 'atlas_doc_format',
+      },
+    },
+    version: {
+      number: page.version.number + 1,
+      message,
+      minorEdit: false,
+    },
+  };
+  const { data } = await getHttpService().put(
+    `/api/v2/pages/${page.id}`,
+    payload,
+  );
+  return data;
+}
+
+const childPagesAdf = {
+  type: 'doc',
+  version: 1,
+  content: [
+    {
+      type: 'extension',
+      attrs: {
+        extensionType: 'com.atlassian.confluence.macro.core',
+        extensionKey: 'children',
+        layout: 'default',
+        parameters: {
+          macroParams: {
+            allChildren: { value: 'true' },
+          },
+          macroMetadata: {
+            macroId: { value: '9ea4beb6-ac0a-42d7-baf1-e8e6eca01bfd' },
+            schemaVersion: { value: '2' },
+            title: { value: 'Child pages' },
+          },
+        },
+        localId: '4890f00c-c519-4947-a60c-0c3b7e1c7b72',
+      },
+    },
+  ],
+};
+
+/** ---------- Main upsert workflow ---------- */
+
+/**
+ * Upsert release notes at: Versions(parent) -> Version(title) -> Component(title)
+ *
+ * @param {object} args
+ * @param {string} args.versionsParentId - Page ID of the "Versions" page
+ * @param {string} args.versionTitle     - e.g. "Version 1"
+ * @param {string} args.componentTitle   - e.g. "Component A"
+ * @param {string} args.markdown         - Release notes markdown for the component page
+ *
+ * @returns {Promise<{versionPage:any, componentPage:any}>}
+ */
+export async function upsertReleaseNotes({
+  versionsParentId,
+  version,
+  component,
+  markdown,
+  group,
+}) {
+  if (!BASE_URL || !EMAIL || !API_TOKEN) {
+    throw new Error(
+      'Missing required env: CONFLUENCE_BASE_URL, CONFLUENCE_EMAIL, CONFLUENCE_API_TOKEN',
+    );
+  }
+
+  if (!versionsParentId || !version || !component) {
+    throw new Error(
+      'versionsParentId, versionTitle, and componentTitle are required',
+    );
+  }
+
+  if (!markdown || markdown.trim() === '') {
+    throw new Error('markdown content is required and cannot be empty');
+  }
+
+  // 1) fetch the parent to get spaceId
+  const parent = await getPage(versionsParentId);
+  const spaceId = parent.spaceId;
+
+  const versionTitle = `Docupace ${group} - Version ${version}`;
+  // 2) ensure Version page under parent
+  let versionPage = await findChildByTitle(parent.id, versionTitle);
+  if (!versionPage) {
+    versionPage = await createChildPage({
+      parentId: parent.id,
+      spaceId,
+      title: versionTitle,
+      adf: JSON.stringify(childPagesAdf),
+      message: `Create version page ${versionTitle}`,
+    });
+  }
+
+  const componentTitle = `${versionTitle} - ${component} Changelog`;
+
+  // 3) ensure Component page under Version
+  let componentPage = await findChildByTitle(versionPage.id, componentTitle);
+  const adf = adfMarkdown(markdown);
+
+  if (!componentPage) {
+    componentPage = await createChildPage({
+      parentId: versionPage.id,
+      spaceId,
+      title: componentTitle,
+      adf: JSON.stringify(adf),
+      message: `Create component page ${componentTitle}`,
+    });
+  } else {
+    // update existing component page with new markdown
+    componentPage = await updatePage({
+      page: componentPage,
+      title: componentTitle,
+      adf: JSON.stringify(adf),
+      message: `Update component page ${componentTitle}`,
+    });
+  }
+
+  return { versionPage, componentPage };
+}
+
+/**
+ * Upsert release notes from a markdown file
+ *
+ * @param {object} args
+ * @param {string} args.versionTitle     - e.g. "Version 1"
+ * @param {string} args.componentTitle   - e.g. "Component A"
+ * @param {string} args.markdownFile     - Path to markdown file
+ *
+ * @returns {Promise<{versionPage:any, componentPage:any}>}
+ */
+export async function upsertReleaseNotesFromFile({
+  version,
+  component,
+  markdownFile,
+  group,
+}) {
+  if (!group) {
+    throw new Error('changelog.group must be specified in package.json');
+  }
+
+  const versionsParentId =
+    process.env[`CONFLUENCE_${group.toUpperCase()}_PARENT_ID`];
+
+  if (!versionsParentId) {
+    throw new Error(
+      `CONFLUENCE_${group.toUpperCase()}_PARENT_ID environment variable is required`,
+    );
+  }
+
+  if (!markdownFile) {
+    throw new Error('markdownFile is required');
+  }
+
+  // Read markdown content from file
+  const markdown = readFileSync(markdownFile, 'utf8');
+
+  return upsertReleaseNotes({
+    versionsParentId,
+    version,
+    component,
+    markdown,
+    group,
+  });
+}
+
+export async function updateWikiWithVersion(releases) {
+  const packageNames = getPackageNames();
+  console.log(releases);
+
+  const promises = packageNames
+    .filter(
+      (packageName) =>
+        releases.find((release) => release.name == packageName.name) &&
+        packageName.content?.changelog?.component,
+    )
+    .map(async (packageName) => {
+      try {
+        const release = releases.find(
+          (release) => release.name == packageName.name,
+        );
+        await upsertReleaseNotesFromFile({
+          version: toShortVersion(release.newVersion),
+          component: packageName.content.changelog?.component,
+          markdownFile: path.join(packageName.path, 'CHANGELOG.md'),
+          group: packageName.content.changelog?.group,
+        });
+        console.log(`✅ Successfully updated wiki for ${packageName.name}`);
+      } catch (error) {
+        console.error(
+          `❌ Failed to update wiki for ${packageName.name}:`,
+          error.message,
+        );
+        // Continue with other packages instead of stopping the build
+      }
+    });
+
+  try {
+    await Promise.all(promises);
+    console.log('✅ Wiki update process completed');
+  } catch (error) {
+    console.error('❌ Error during wiki update process:', error.message);
+    // Don't throw the error to prevent build failure
+  }
+}

package/src/changeset/changeset-config.js

@@ -0,0 +1,34 @@
+import fs from 'fs';
+import path from 'path';
+
+// Get absolute path to .changeset/config.json using current working directory
+const configPath = path.join(process.cwd(), '.changeset', 'config.json');
+
+// Function to update baseBranch to BITBUCKET_BRANCH
+export function updateBaseBranch() {
+  const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+  if (!process.env.BITBUCKET_BRANCH) {
+    return null;
+  }
+  let originalbaseBranch = config.baseBranch;
+  config.baseBranch = process.env.BITBUCKET_BRANCH;
+
+  if (!config.baseBranch) {
+    throw new Error('BITBUCKET_BRANCH environment variable is not set.');
+  }
+
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+  console.log(`baseBranch updated to ${process.env.BITBUCKET_BRANCH}`);
+
+  return originalbaseBranch;
+}
+
+// Function to revert baseBranch to original value
+export function revertBaseBranch(originalBaseBranch) {
+  if (!originalBaseBranch) return;
+
+  const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+  config.baseBranch = originalBaseBranch;
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+  console.log(`baseBranch reverted to ${originalBaseBranch}`);
+}