ci-cd/.github/actions/bump-version/action.yaml

name: Bump Version
description: Bump npm version, create tag, and push
inputs:
  node_version:
    description: Node.js version to use
    required: false
    default: "24"
  release_line:
    description: Release line for dev builds (e.g. 2.4) when it cannot be derived from the branch or PR target
    required: false
    default: ""
  gitea_token:
    description: Token for checkout/push (optional)
    required: false
    default: ""
outputs:
  tag:
    description: Created tag
    value: ${{ steps.bump.outputs.tag }}
runs:
  using: "composite"
  steps:
    - name: Checkout
      uses: actions/checkout@v3
      with:
        fetch-depth: 0
        fetch-tags: true
        token: ${{ inputs.gitea_token != '' && inputs.gitea_token || github.token }}

    - name: Setup Git
      shell: bash
      run: |
        git config user.name "CI Bot"
        git config user.email "ci@git.uesome.de"

    - name: Setup Node
      uses: actions/setup-node@v3
      with:
        node-version: ${{ inputs.node_version }}

    - name: Bump version and tag
      id: bump
      shell: bash
      env:
        INPUT_RELEASE_LINE: ${{ inputs.release_line }}
      run: |
        set -euo pipefail

        REF="${GITHUB_HEAD_REF:-${GITEA_HEAD_REF:-${GITHUB_REF:-${GITEA_REF:-}}}}"
        BASE_REF="${GITHUB_BASE_REF:-${GITEA_BASE_REF:-}}"
        BRANCH="${REF#refs/heads/}"
        BASE_BRANCH="${BASE_REF#refs/heads/}"

        if [[ -z "${BRANCH}" ]]; then
          echo "Unable to determine branch from workflow context." >&2
          exit 1
        fi

        git fetch origin "${BRANCH}" --tags
        git checkout "${BRANCH}"
        git pull --ff-only origin "${BRANCH}"

        set_version() {
          npm version "$1" --no-git-tag-version --allow-same-version >/dev/null
        }

        read_package_version() {
          node -p "require('./package.json').version"
        }

        validate_release_line() {
          local line="$1"
          [[ "${line}" =~ ^[0-9]+\.[0-9]+$ ]]
        }

        extract_release_line() {
          local ref_name="$1"
          if [[ "${ref_name}" =~ ^release/v?([0-9]+)\.([0-9]+)$ ]]; then
            echo "${BASH_REMATCH[1]}.${BASH_REMATCH[2]}"
            return 0
          fi
          return 1
        }

        resolve_release_line() {
          local package_version

          if [[ -n "${INPUT_RELEASE_LINE}" ]]; then
            if ! validate_release_line "${INPUT_RELEASE_LINE}"; then
              echo "Invalid release_line input '${INPUT_RELEASE_LINE}'. Expected format: <major>.<minor>" >&2
              exit 1
            fi
            echo "${INPUT_RELEASE_LINE}"
            return 0
          fi

          if extract_release_line "${BRANCH}" >/dev/null; then
            extract_release_line "${BRANCH}"
            return 0
          fi

          if [[ -n "${BASE_BRANCH}" ]] && extract_release_line "${BASE_BRANCH}" >/dev/null; then
            extract_release_line "${BASE_BRANCH}"
            return 0
          fi

          package_version="$(read_package_version)"
          if [[ "${package_version}" =~ ^([0-9]+)\.([0-9]+)\.[0-9]+([-.].*)?$ ]]; then
            echo "${BASH_REMATCH[1]}.${BASH_REMATCH[2]}"
            return 0
          fi

          echo "Unable to determine release line for branch '${BRANCH}'. Use release/<major>.<minor>, provide inputs.release_line, or ensure package.json contains a semantic version." >&2
          exit 1
        }

        next_beta_version() {
          local release_base="$1"
          local escaped_base
          local highest_beta
          escaped_base="$(printf '%s' "${release_base}" | sed 's/\./\\./g')"
          highest_beta="$(
            git tag --list "v${release_base}-beta.*" \
              | sed -nE "s/^v${escaped_base}-beta\.([0-9]+)$/\\1/p" \
              | sort -n \
              | tail -n 1
          )"
          if [[ -z "${highest_beta}" ]]; then
            echo "${release_base}-beta.0"
          else
            echo "${release_base}-beta.$((highest_beta + 1))"
          fi
        }

        next_dev_version() {
          local release_base="$1"
          local timestamp
          while true; do
            timestamp="$(date -u +%Y%m%d%H%M%S)"
            if ! git rev-parse -q --verify "refs/tags/v${release_base}-dev.${timestamp}" >/dev/null; then
              echo "${release_base}-dev.${timestamp}"
              return 0
            fi
            sleep 1
          done
        }

        case "${BRANCH}" in
          main)
            COMMIT_MSG="$(git log -1 --pretty=%B)"
            TARGET_VERSION=""
            if [[ "${COMMIT_MSG}" =~ release/v?([0-9]+\.[0-9]+\.[0-9]+) ]]; then
              TARGET_VERSION="${BASH_REMATCH[1]}"
            elif [[ "${COMMIT_MSG}" =~ release/([0-9]+)\.([0-9]+) ]]; then
              TARGET_VERSION="${BASH_REMATCH[1]}.${BASH_REMATCH[2]}.0"
            elif [[ "${COMMIT_MSG}" =~ hotfix/([0-9]+\.[0-9]+\.[0-9]+) ]]; then
              TARGET_VERSION="${BASH_REMATCH[1]}"
            fi

            if [[ -n "${TARGET_VERSION}" ]]; then
              set_version "${TARGET_VERSION}"
            else
              npm version patch --no-git-tag-version >/dev/null
            fi
            ;;
          release/*)
            RELEASE_LINE="$(resolve_release_line)"
            RELEASE_BASE="${RELEASE_LINE}.0"
            set_version "$(next_beta_version "${RELEASE_BASE}")"
            ;;
          *)
            RELEASE_LINE="$(resolve_release_line)"
            RELEASE_BASE="${RELEASE_LINE}.0"
            set_version "$(next_dev_version "${RELEASE_BASE}")"
            ;;
        esac

        VERSION="$(node -p "require('./package.json').version")"
        while git rev-parse -q --verify "refs/tags/v${VERSION}" >/dev/null; do
          echo "Tag v${VERSION} already exists; trying next version."
          case "${BRANCH}" in
            main)
              npm version patch --no-git-tag-version >/dev/null
              ;;
            release/*)
              set_version "$(next_beta_version "${RELEASE_BASE}")"
              ;;
            *)
              set_version "$(next_dev_version "${RELEASE_BASE}")"
              ;;
          esac
          VERSION="$(read_package_version)"
        done

        if git diff --quiet; then
          echo "No version file changes; tagging current commit."
        else
          git add package.json package-lock.json 2>/dev/null || true
          git commit -m "update version: v${VERSION}"
        fi
        TAG="v${VERSION}"
        git tag "${TAG}"

        git push origin HEAD
        git push origin "${TAG}"

        echo "tag=${TAG}" >> "${GITHUB_OUTPUT}"