Skip to content

Database governance built for humans and agents — controlling changes and access across every major database.

8.0 KB
Raw Blame
import semver from "semver";
import { GENERATED_WORKFLOW_AUDIENCE } from "@/utils/workloadIdentity";

// bytebase-action exits when its version is incompatible with the server's: a
// Cloud server needs the :cloud image, and a self-hosted server rejects a newer
// minor release, which the untagged `latest` image can be.
export function bytebaseActionImage(serverVersion: string): string {
  if (serverVersion.startsWith("cloud")) {
    return "bytebase/bytebase-action:cloud";
  }
  const version = semver.valid(serverVersion);
  return version
    ? `bytebase/bytebase-action:${version}`
    : "bytebase/bytebase-action";
}

export interface YamlParams {
  branch: string;
  runsOn?: string;
  bytebaseUrl: string;
  actionImage: string;
  workloadIdentityEmail: string;
  projectId: string;
  targetsPlaceholder: string;
}

const exchangeTokenStep = (indent: string) =>
  `${indent}- name: Exchange token
${indent}  id: bytebase-auth
${indent}  run: |
${indent}    OIDC_TOKEN=$(curl -s -H "Authorization: bearer $ACTIONS_ID_TOKEN_REQUEST_TOKEN" \\
${indent}      "$ACTIONS_ID_TOKEN_REQUEST_URL&audience=${GENERATED_WORKFLOW_AUDIENCE}" | jq -r '.value // empty' 2>/dev/null || true)
${indent}    if [ -z "$OIDC_TOKEN" ]; then
${indent}      echo "::error::Failed to get a GitHub OIDC token. Check that the job has the id-token: write permission."
${indent}      exit 1
${indent}    fi
${indent}    RESPONSE=$(curl -s -X POST "$BYTEBASE_URL/v1/auth:exchangeToken" \\
${indent}      -H "Content-Type: application/json" \\
${indent}      -d "{\\"token\\":\\"$OIDC_TOKEN\\",\\"email\\":\\"$BYTEBASE_WORKLOAD_IDENTITY\\"}")
${indent}    ACCESS_TOKEN=$(echo "$RESPONSE" | jq -r '.accessToken // empty' 2>/dev/null || true)
${indent}    if [ -z "$ACCESS_TOKEN" ]; then
${indent}      echo "::error::Failed to exchange the OIDC token for a Bytebase access token: $RESPONSE"
${indent}      exit 1
${indent}    fi
${indent}    echo "access-token=$ACCESS_TOKEN" >> $GITHUB_OUTPUT`;

const accessTokenFlag =
  "--access-token=${{ steps.bytebase-auth.outputs.access-token }}";

export function generateGithubSqlReviewYaml(p: YamlParams): string {
  return `name: SQL Review
on:
  pull_request:
    branches: ["${p.branch}"]
    paths: ["migrations/*.sql"]
jobs:
  sql-review:
    permissions:
      id-token: write
      pull-requests: write
    runs-on: ${p.runsOn}
    container:
      image: ${p.actionImage}
    env:
      BYTEBASE_URL: ${p.bytebaseUrl}
      BYTEBASE_WORKLOAD_IDENTITY: ${p.workloadIdentityEmail}
    steps:
      - uses: actions/checkout@v4
${exchangeTokenStep("      ")}
      - name: SQL Review
        env:
          GITHUB_TOKEN: \${{ secrets.GITHUB_TOKEN }}
        run: |
          bytebase-action check \\
            --url=$BYTEBASE_URL \\
            ${accessTokenFlag} \\
            --project=projects/${p.projectId} \\
            --targets=${p.targetsPlaceholder} \\
            --file-pattern=migrations/*.sql`;
}

export function generateGithubReleaseYaml(p: YamlParams): string {
  return `name: Rollout
on:
  push:
    branches: ["${p.branch}"]
    paths: ["migrations/*.sql"]
env:
  BYTEBASE_URL: ${p.bytebaseUrl}
  BYTEBASE_WORKLOAD_IDENTITY: ${p.workloadIdentityEmail}
  BYTEBASE_PROJECT: projects/${p.projectId}
jobs:
  build:
    runs-on: ${p.runsOn}
    steps:
      - uses: actions/checkout@v4
      - name: Build
        run: echo "Building..."
  create-rollout:
    needs: build
    permissions:
      id-token: write
    runs-on: ${p.runsOn}
    container:
      image: ${p.actionImage}
    outputs:
      bytebase-plan: \${{ steps.set-output.outputs.plan }}
    steps:
      - uses: actions/checkout@v4
${exchangeTokenStep("      ")}
      - name: Create rollout
        run: |
          bytebase-action rollout \\
            --url=$BYTEBASE_URL \\
            ${accessTokenFlag} \\
            --project=$BYTEBASE_PROJECT \\
            --targets=${p.targetsPlaceholder} \\
            --file-pattern=migrations/*.sql \\
            --output=\${{ runner.temp }}/bytebase-metadata.json
      - name: Set output
        id: set-output
        run: |
          PLAN=$(jq -r .plan \${{ runner.temp }}/bytebase-metadata.json)
          echo "plan=$PLAN" >> $GITHUB_OUTPUT
  deploy-to-test:
    needs: create-rollout
    permissions:
      id-token: write
    runs-on: ${p.runsOn}
    environment: test
    container:
      image: ${p.actionImage}
    steps:
      - uses: actions/checkout@v4
${exchangeTokenStep("      ")}
      - name: Deploy to test
        run: |
          bytebase-action rollout \\
            --url=$BYTEBASE_URL \\
            ${accessTokenFlag} \\
            --project=$BYTEBASE_PROJECT \\
            --target-stage=environments/test \\
            --plan=\${{ needs.create-rollout.outputs.bytebase-plan }}
  deploy-to-prod:
    needs: [deploy-to-test, create-rollout]
    permissions:
      id-token: write
    runs-on: ${p.runsOn}
    environment: prod
    container:
      image: ${p.actionImage}
    steps:
      - uses: actions/checkout@v4
${exchangeTokenStep("      ")}
      - name: Deploy to prod
        run: |
          bytebase-action rollout \\
            --url=$BYTEBASE_URL \\
            ${accessTokenFlag} \\
            --project=$BYTEBASE_PROJECT \\
            --target-stage=environments/prod \\
            --plan=\${{ needs.create-rollout.outputs.bytebase-plan }}`;
}

const gitlabExchangeScript = `    - |
      RESPONSE=$(curl -s -X POST "$BYTEBASE_URL/v1/auth:exchangeToken" \\
        -H "Content-Type: application/json" \\
        -d "{\\"token\\":\\"$GITLAB_OIDC_TOKEN\\",\\"email\\":\\"$BYTEBASE_WORKLOAD_IDENTITY\\"}")
      ACCESS_TOKEN=$(echo "$RESPONSE" | jq -r '.accessToken // empty' 2>/dev/null || true)
      if [ -z "$ACCESS_TOKEN" ]; then
        echo "Failed to exchange the GitLab OIDC token for a Bytebase access token: $RESPONSE"
        exit 1
      fi
      export BYTEBASE_ACCESS_TOKEN=$ACCESS_TOKEN`;

export function generateGitlabCiYaml(p: YamlParams): string {
  return `stages:
  - sql-review
  - create-rollout
  - deploy-to-test
  - deploy-to-prod

variables:
  BYTEBASE_URL: ${p.bytebaseUrl}
  BYTEBASE_WORKLOAD_IDENTITY: ${p.workloadIdentityEmail}
  BYTEBASE_PROJECT: projects/${p.projectId}
  BYTEBASE_TARGETS: ${p.targetsPlaceholder}
  FILE_PATTERN: "migrations/*.sql"

sql-review:
  stage: sql-review
  image: ${p.actionImage}
  id_tokens:
    GITLAB_OIDC_TOKEN:
      aud: ${GENERATED_WORKFLOW_AUDIENCE}
  rules:
    - if: $CI_PIPELINE_SOURCE == "merge_request_event"
  script:
${gitlabExchangeScript}
    - bytebase-action check --url=$BYTEBASE_URL --access-token=$BYTEBASE_ACCESS_TOKEN --project=$BYTEBASE_PROJECT --targets=$BYTEBASE_TARGETS --file-pattern=$FILE_PATTERN

create-rollout:
  stage: create-rollout
  image: ${p.actionImage}
  id_tokens:
    GITLAB_OIDC_TOKEN:
      aud: ${GENERATED_WORKFLOW_AUDIENCE}
  rules:
    - if: $CI_COMMIT_BRANCH == "${p.branch}"
  script:
${gitlabExchangeScript}
    - bytebase-action rollout --url=$BYTEBASE_URL --access-token=$BYTEBASE_ACCESS_TOKEN --project=$BYTEBASE_PROJECT --targets=$BYTEBASE_TARGETS --file-pattern=$FILE_PATTERN --output=bytebase-metadata.json
  artifacts:
    paths: [bytebase-metadata.json]

deploy-to-test:
  stage: deploy-to-test
  image: ${p.actionImage}
  needs: [create-rollout]
  id_tokens:
    GITLAB_OIDC_TOKEN:
      aud: ${GENERATED_WORKFLOW_AUDIENCE}
  rules:
    - if: $CI_COMMIT_BRANCH == "${p.branch}"
  environment: test
  script:
${gitlabExchangeScript}
    - PLAN=$(jq -r .plan bytebase-metadata.json)
    - bytebase-action rollout --url=$BYTEBASE_URL --access-token=$BYTEBASE_ACCESS_TOKEN --project=$BYTEBASE_PROJECT --target-stage=environments/test --plan=$PLAN

deploy-to-prod:
  stage: deploy-to-prod
  image: ${p.actionImage}
  needs: [create-rollout, deploy-to-test]
  id_tokens:
    GITLAB_OIDC_TOKEN:
      aud: ${GENERATED_WORKFLOW_AUDIENCE}
  rules:
    - if: $CI_COMMIT_BRANCH == "${p.branch}"
  environment: prod
  when: manual
  script:
${gitlabExchangeScript}
    - PLAN=$(jq -r .plan bytebase-metadata.json)
    - bytebase-action rollout --url=$BYTEBASE_URL --access-token=$BYTEBASE_ACCESS_TOKEN --project=$BYTEBASE_PROJECT --target-stage=environments/prod --plan=$PLAN`;
}