@hellopearl/dv-gitlab 0.4.4 → 0.5.0

package/src/commands/release-promote.mjs

@@ -0,0 +1,225 @@
+import { log } from '../lib/logger.mjs';
+
+/**
+ * @param {string} key
+ * @param {string} [fallback]
+ * @returns {string}
+ */
+function env(key, fallback = '') {
+  return process.env[key] || fallback;
+}
+
+/**
+ * Computes the next semver patch tag from a list of existing tag names.
+ * @param {string[]} tagNames
+ * @returns {string}
+ */
+export function bumpPatch(tagNames) {
+  const semverTags = tagNames
+    .filter(n => /^v\d+\.\d+\.\d+$/.test(n))
+    .map(n => {
+      const [major, minor, patch] = n.slice(1).split('.').map(Number);
+      return { major, minor, name: n, patch };
+    })
+    .sort(
+      (a, b) => a.major - b.major || a.minor - b.minor || a.patch - b.patch,
+    );
+
+  if (!semverTags.length) {
+    return 'v0.0.1';
+  }
+
+  const latest = semverTags[semverTags.length - 1];
+  return `v${latest.major}.${latest.minor}.${latest.patch + 1}`;
+}
+
+/**
+ * Computes the tag name for the requested environment.
+ * @param {string} releaseEnv
+ * @param {string[]} existingTags - all tag names (for version bumping)
+ * @param {string} [explicitVersion] - explicit version override for production
+ * @returns {{ tag: string, skip: boolean, error?: string }}
+ */
+export function computeTag(releaseEnv, existingTags = [], explicitVersion) {
+  const ts = new Date().toISOString().replace(/[-T:]/g, '').slice(0, 12);
+  const tsFormatted = `${ts.slice(0, 8)}.${ts.slice(8)}`;
+
+  switch (releaseEnv) {
+    case 'sandbox':
+      return { skip: false, tag: `sb-${tsFormatted}` };
+    case 'stage':
+      return { skip: false, tag: `rc-${tsFormatted}` };
+    case 'production': {
+      const next = bumpPatch(existingTags);
+      return { skip: false, tag: explicitVersion || next };
+    }
+    default:
+      return {
+        error: `Unknown RELEASE_ENV '${releaseEnv}'. ${
+          releaseEnv === 'dev'
+            ? 'Dev deploys automatically on merge to main — no tag needed.'
+            : 'Expected: sandbox, stage, production'
+        }`,
+        skip: true,
+        tag: '',
+      };
+  }
+}
+
+/**
+ * Posts a Slack message via incoming webhook.
+ * @param {string} webhookUrl
+ * @param {string} message
+ * @param {string} [channel]
+ */
+async function postSlack(webhookUrl, message, channel) {
+  const payload = { text: message };
+  if (channel) {
+    payload.channel = channel;
+  }
+
+  const res = await fetch(webhookUrl, {
+    body: JSON.stringify(payload),
+    headers: { 'Content-Type': 'application/json' },
+    method: 'POST',
+  });
+
+  if (!res.ok) {
+    log(`[release-promote] Slack notification failed: HTTP ${res.status}`);
+  }
+}
+
+/**
+ * Fetches all tags from GitLab API.
+ * @param {string} apiUrl
+ * @param {string} projectId
+ * @param {string} token
+ * @returns {Promise<string[]>}
+ */
+async function fetchTags(apiUrl, projectId, token) {
+  const res = await fetch(
+    `${apiUrl}/projects/${encodeURIComponent(projectId)}/repository/tags?per_page=100&order_by=version`,
+    { headers: { 'PRIVATE-TOKEN': token } },
+  );
+
+  if (!res.ok) {
+    log(`[release-promote] Failed to fetch tags: HTTP ${res.status}`);
+    return [];
+  }
+
+  const tags = await res.json();
+  return tags.map(t => t.name);
+}
+
+/**
+ * Creates a git tag via GitLab API.
+ * @param {string} apiUrl
+ * @param {string} projectId
+ * @param {string} token
+ * @param {string} tagName
+ * @param {string} ref
+ * @returns {Promise<{ name: string, shortId: string }>}
+ */
+async function createTag(apiUrl, projectId, token, tagName, ref) {
+  const res = await fetch(
+    `${apiUrl}/projects/${encodeURIComponent(projectId)}/repository/tags`,
+    {
+      body: new URLSearchParams({ ref, tag_name: tagName }),
+      headers: {
+        'Content-Type': 'application/x-www-form-urlencoded',
+        'PRIVATE-TOKEN': token,
+      },
+      method: 'POST',
+    },
+  );
+
+  if (!res.ok) {
+    const body = await res.text();
+    throw new Error(
+      `Failed to create tag '${tagName}': HTTP ${res.status} — ${body}`,
+    );
+  }
+
+  const data = await res.json();
+  return { name: data.name, shortId: data.commit?.short_id || 'unknown' };
+}
+
+/**
+ * Promote a release to the specified environment by creating a git tag.
+ * Reads configuration from environment variables.
+ */
+export async function releasePromote() {
+  const releaseEnv = env('RELEASE_ENV');
+
+  if (!releaseEnv) {
+    log('[release-promote] RELEASE_ENV not set — skipping.');
+    return;
+  }
+
+  // Dev deploys automatically when merged to main — no tag, no promotion.
+  // Guard at the code level so even a manual RELEASE_ENV=dev is a clean no-op.
+  if (releaseEnv === 'dev') {
+    log(
+      '[release-promote] Dev deploys automatically on merge to main — no tag needed. Skipping.',
+    );
+    return;
+  }
+
+  log('══════════════════════════════════════════');
+  log(`[release-promote] Environment: ${releaseEnv}`);
+  log('══════════════════════════════════════════');
+
+  const token = env('RELEASE_TOKEN');
+  const apiUrl = env('CI_API_V4_URL', 'https://gitlab.com/api/v4');
+  const projectId = env('CI_PROJECT_ID');
+  const projectName = env('CI_PROJECT_NAME', 'app');
+  const triggeredBy = env('GITLAB_USER_LOGIN', 'ci');
+  const ref = env('RELEASE_SHA') || env('PROMOTE_DEFAULT_BRANCH', 'main');
+
+  if (!token) {
+    throw new Error(
+      'RELEASE_TOKEN CI variable not set. ' +
+        'Set it as a project CI variable (PAT or deploy token with write_repository scope).',
+    );
+  }
+
+  let existingTags = [];
+  if (releaseEnv === 'production') {
+    existingTags = await fetchTags(apiUrl, projectId, token);
+  }
+
+  const explicitVersion = env('RELEASE_VERSION');
+  const result = computeTag(
+    releaseEnv,
+    existingTags,
+    explicitVersion || undefined,
+  );
+
+  if (result.error) {
+    throw new Error(result.error);
+  }
+
+  log(`Tag: ${result.tag}`);
+  log(`Ref: ${ref}`);
+  log('');
+
+  const created = await createTag(apiUrl, projectId, token, result.tag, ref);
+  log(`Tag '${created.name}' created (commit: ${created.shortId})`);
+
+  log('');
+  log('══════════════════════════════════════════');
+  log(`[release-promote] Tag '${result.tag}' created on '${ref}'.`);
+  log('[release-promote] Promotion pipeline will fire automatically.');
+  log('══════════════════════════════════════════');
+
+  const slackWebhook = env('SLACK_WEBHOOK_URL');
+  const slackChannel = env('PROMOTE_SLACK_CHANNEL') || env('SLACK_CHANNEL');
+
+  if (slackWebhook) {
+    const message =
+      `:arrow_up: *${projectName}* promoted to *${releaseEnv}* by @${triggeredBy}\n` +
+      `Tag: \`${result.tag}\` | Commit: \`${created.shortId}\``;
+    await postSlack(slackWebhook, message, slackChannel);
+    log('[release-promote] Slack notification sent.');
+  }
+}

package/src/commands/release-rollback.mjs

@@ -0,0 +1,233 @@
+import { log } from '../lib/logger.mjs';
+
+/**
+ * @param {string} key
+ * @param {string} [fallback]
+ * @returns {string}
+ */
+function env(key, fallback = '') {
+  return process.env[key] || fallback;
+}
+
+/**
+ * Finds the previous tag matching a pattern from a list of tags.
+ * Tags are expected to be sorted by creation date (newest first from GitLab API).
+ * @param {Array<{name: string, commit: {created_at: string}}>} tags
+ * @param {RegExp} pattern
+ * @param {string} currentTag - the tag to roll back from (skip it)
+ * @returns {{ name: string, commitDate: string } | null}
+ */
+export function findPreviousTag(tags, pattern, currentTag) {
+  for (const tag of tags) {
+    if (tag.name === currentTag) {
+      continue;
+    }
+    if (pattern.test(tag.name)) {
+      return { commitDate: tag.commit?.created_at || '', name: tag.name };
+    }
+  }
+  return null;
+}
+
+/**
+ * Determines the tag pattern for an environment.
+ * @param {string} releaseEnv
+ * @returns {{ pattern: RegExp, error?: string }}
+ */
+export function tagPatternForEnv(releaseEnv) {
+  switch (releaseEnv) {
+    case 'production':
+      return { pattern: /^v\d+\.\d+\.\d+$/ };
+    case 'stage':
+      return { pattern: /^rc-\d{8}\.\d{4}$/ };
+    case 'sandbox':
+      return { pattern: /^sb-\d{8}\.\d{4}$/ };
+    default:
+      return {
+        error: `Cannot rollback '${releaseEnv}'. Supported: production, stage, sandbox`,
+        pattern: /$^/,
+      };
+  }
+}
+
+/**
+ * Fetches tags from GitLab API, sorted by creation date descending.
+ * @param {string} apiUrl
+ * @param {string} projectId
+ * @param {string} token
+ * @returns {Promise<Array<{name: string, commit: {created_at: string}}>>}
+ */
+async function fetchTagsSorted(apiUrl, projectId, token) {
+  const res = await fetch(
+    `${apiUrl}/projects/${encodeURIComponent(projectId)}/repository/tags?per_page=100&order_by=updated&sort=desc`,
+    { headers: { 'PRIVATE-TOKEN': token } },
+  );
+
+  if (!res.ok) {
+    throw new Error(`Failed to fetch tags: HTTP ${res.status}`);
+  }
+
+  return res.json();
+}
+
+/**
+ * Creates a git tag via GitLab API pointing to a specific commit.
+ * @param {string} apiUrl
+ * @param {string} projectId
+ * @param {string} token
+ * @param {string} tagName
+ * @param {string} ref
+ * @returns {Promise<{ name: string, shortId: string }>}
+ */
+async function createTag(apiUrl, projectId, token, tagName, ref) {
+  const res = await fetch(
+    `${apiUrl}/projects/${encodeURIComponent(projectId)}/repository/tags`,
+    {
+      body: new URLSearchParams({ ref, tag_name: tagName }),
+      headers: {
+        'Content-Type': 'application/x-www-form-urlencoded',
+        'PRIVATE-TOKEN': token,
+      },
+      method: 'POST',
+    },
+  );
+
+  if (!res.ok) {
+    const body = await res.text();
+    throw new Error(
+      `Failed to create rollback tag '${tagName}': HTTP ${res.status} — ${body}`,
+    );
+  }
+
+  const data = await res.json();
+  return { name: data.name, shortId: data.commit?.short_id || 'unknown' };
+}
+
+/**
+ * Rolls back an environment to the previous release by creating a new tag
+ * pointing to the same commit as the previous tag.
+ *
+ * For production: finds the previous v* tag, creates a new v*.*.* tag
+ * For stage: finds the previous rc-* tag, creates a new rc-* tag
+ * For sandbox: finds the previous sb-* tag, creates a new sb-* tag
+ */
+export async function releaseRollback() {
+  const releaseEnv = env('ROLLBACK_ENV') || env('RELEASE_ENV');
+
+  if (!releaseEnv) {
+    log('[release-rollback] ROLLBACK_ENV not set — skipping.');
+    return;
+  }
+
+  const token = env('RELEASE_TOKEN');
+  if (!token) {
+    throw new Error(
+      'RELEASE_TOKEN CI variable not set. ' +
+        'Set it as a project CI variable (PAT or deploy token with write_repository scope).',
+    );
+  }
+
+  const apiUrl = env('CI_API_V4_URL', 'https://gitlab.com/api/v4');
+  const projectId = env('CI_PROJECT_ID');
+  const projectName = env('CI_PROJECT_NAME', 'app');
+  const triggeredBy = env('GITLAB_USER_LOGIN', 'ci');
+
+  log('══════════════════════════════════════════');
+  log(`[release-rollback] Rolling back: ${releaseEnv}`);
+  log('══════════════════════════════════════════');
+
+  const { pattern, error } = tagPatternForEnv(releaseEnv);
+  if (error) {
+    throw new Error(error);
+  }
+
+  const tags = await fetchTagsSorted(apiUrl, projectId, token);
+  const currentTags = tags.filter(t => pattern.test(t.name));
+
+  if (currentTags.length < 2) {
+    throw new Error(
+      `Cannot rollback: fewer than 2 ${releaseEnv} tags found. Need at least a current and a previous release.`,
+    );
+  }
+
+  const currentTag = currentTags[0].name;
+  const previous = findPreviousTag(tags, pattern, currentTag);
+
+  if (!previous) {
+    throw new Error(
+      `Cannot find a previous ${releaseEnv} tag to rollback to (current: ${currentTag}).`,
+    );
+  }
+
+  log(`Current:  ${currentTag}`);
+  log(`Rollback to: ${previous.name}`);
+  log('');
+
+  const rollbackTagName = env('ROLLBACK_TAG');
+  let newTag;
+
+  if (rollbackTagName) {
+    newTag = await createTag(
+      apiUrl,
+      projectId,
+      token,
+      rollbackTagName,
+      previous.name,
+    );
+  } else {
+    const ts = new Date().toISOString().replace(/[-T:]/g, '').slice(0, 12);
+    const tsFormatted = `${ts.slice(0, 8)}.${ts.slice(8)}`;
+
+    let autoName;
+    switch (releaseEnv) {
+      case 'production': {
+        const parts = currentTag.slice(1).split('.').map(Number);
+        autoName = `v${parts[0]}.${parts[1]}.${parts[2] + 1}`;
+        break;
+      }
+      case 'stage':
+        autoName = `rc-${tsFormatted}`;
+        break;
+      case 'sandbox':
+        autoName = `sb-${tsFormatted}`;
+        break;
+    }
+
+    newTag = await createTag(apiUrl, projectId, token, autoName, previous.name);
+  }
+
+  log(`Rollback tag '${newTag.name}' created (commit: ${newTag.shortId})`);
+  log('');
+  log('══════════════════════════════════════════');
+  log(
+    `[release-rollback] ${releaseEnv} rolling back from '${currentTag}' to '${previous.name}' via tag '${newTag.name}'.`,
+  );
+  log('[release-rollback] Promotion pipeline will fire automatically.');
+  log('══════════════════════════════════════════');
+
+  const slackWebhook = env('SLACK_WEBHOOK_URL');
+  const slackChannel = env('PROMOTE_SLACK_CHANNEL') || env('SLACK_CHANNEL');
+
+  if (slackWebhook) {
+    const message =
+      `:rotating_light: *${projectName}* rollback on *${releaseEnv}* by @${triggeredBy}\n` +
+      `From: \`${currentTag}\` → To: \`${previous.name}\` via tag \`${newTag.name}\``;
+
+    const payload = { text: message };
+    if (slackChannel) {
+      payload.channel = slackChannel;
+    }
+
+    const res = await fetch(slackWebhook, {
+      body: JSON.stringify(payload),
+      headers: { 'Content-Type': 'application/json' },
+      method: 'POST',
+    });
+
+    if (!res.ok) {
+      log(`[release-rollback] Slack notification failed: HTTP ${res.status}`);
+    } else {
+      log('[release-rollback] Slack notification sent.');
+    }
+  }
+}