release.yml

---
name: Release

on:
  push:
    tags:
      - 'v[0-9]+.*'
      - '*-cli-v[0-9]+.*'
      - '*-libs-v[0-9]+.*'

  workflow_dispatch:
    inputs:
      version:
        description: 'Version to release (e.g., 0.1.0)'
        required: true
        type: string
      release-type:
        description: 'Release type'
        required: true
        type: choice
        options:
          - all
          - libraries
          - cli
        default: all
      dry-run:
        description: 'Dry run (no actual publishing)'
        required: false
        type: boolean
        default: false
      skip-tests:
        description: 'Skip tests (use with caution)'
        required: false
        type: boolean
        default: false

env:
  CARGO_TERM_COLOR: always
  RUST_BACKTRACE: 1
  RUSTFLAGS: -D warnings
  CARGO_INCREMENTAL: 0

concurrency:
  group: release-${{ github.repository }}
  cancel-in-progress: false

permissions:
  contents: write
  packages: write

jobs:
  determine-release-type:
    name: Determine Release Type
    runs-on: ubuntu-latest
    outputs:
      release-libraries: ${{ steps.determine.outputs.release-libraries }}
      release-cli: ${{ steps.determine.outputs.release-cli }}
      version: ${{ steps.determine.outputs.version }}
      dry-run: ${{ steps.determine.outputs.dry-run }}
      skip-tests: ${{ steps.determine.outputs.skip-tests }}
    steps:
      - name: Determine what to release
        id: determine
        env:
          TAG_PREFIX: ${{ vars.TAG_PREFIX }}
          BINARY_DEFAULT: ${{ vars.BINARY_DEFAULT }}
          EVENT_NAME: ${{ github.event_name }}
          INPUT_VERSION: ${{ inputs.version }}
          INPUT_RELEASE_TYPE: ${{ inputs.release-type }}
          INPUT_DRY_RUN: ${{ inputs.dry-run }}
          INPUT_SKIP_TESTS: ${{ inputs.skip-tests }}
        run: |
          set +u  # Allow unset variables (GitHub vars may be empty)

          if [[ "$EVENT_NAME" == "workflow_dispatch" ]]; then
            VERSION="$INPUT_VERSION"
            RELEASE_TYPE="$INPUT_RELEASE_TYPE"
            DRY_RUN="$INPUT_DRY_RUN"
            SKIP_TESTS="$INPUT_SKIP_TESTS"
          else
            TAG="${GITHUB_REF#refs/tags/}"
            CLI_TAG_PREFIX="${BINARY_DEFAULT}-v"

            if [[ "$TAG" == "${CLI_TAG_PREFIX}"* ]]; then
              VERSION="${TAG#"${CLI_TAG_PREFIX}"}"
              RELEASE_TYPE="cli"
            elif [[ "$TAG" == *-libs-v* ]]; then
              VERSION="${TAG#*-libs-v}"
              RELEASE_TYPE="libraries"
            else
              VERSION="${TAG#"${TAG_PREFIX}"}"
              RELEASE_TYPE="all"
            fi
            DRY_RUN="false"
            SKIP_TESTS="false"
          fi

          {
            echo "version=$VERSION"
            echo "dry-run=$DRY_RUN"
            echo "skip-tests=$SKIP_TESTS"
          } >> "$GITHUB_OUTPUT"

          case "$RELEASE_TYPE" in
            all)
              echo "release-libraries=true" >> "$GITHUB_OUTPUT"
              echo "release-cli=true" >> "$GITHUB_OUTPUT"
              echo "::notice::Releasing both libraries and CLI for v$VERSION"
              ;;
            libraries)
              echo "release-libraries=true" >> "$GITHUB_OUTPUT"
              echo "release-cli=false" >> "$GITHUB_OUTPUT"
              echo "::notice::Releasing libraries only for v$VERSION"
              ;;
            cli)
              echo "release-libraries=false" >> "$GITHUB_OUTPUT"
              echo "release-cli=true" >> "$GITHUB_OUTPUT"
              echo "::notice::Releasing CLI only for v$VERSION"
              ;;
          esac

          if [[ "$DRY_RUN" == "true" ]]; then
            echo "::warning::DRY RUN MODE - No actual publishing will occur"
          fi

  release-libraries:
    name: Release Libraries
    needs: determine-release-type
    if: needs.determine-release-type.outputs.release-libraries == 'true'
    runs-on: ubuntu-latest
    steps:
      - name: Checkout repository
        uses: actions/checkout@v4

      - name: Install Rust toolchain
        uses: dtolnay/rust-toolchain@v1
        with:
          toolchain: stable

      - name: Cache Rust dependencies
        uses: Swatinem/rust-cache@v2

      - name: Verify versions match
        env:
          PACKAGE_NAMES: ${{ vars.PACKAGE_NAMES || '' }}
        run: |
          VERSION="${{ needs.determine-release-type.outputs.version }}"
          if [ -n "$PACKAGE_NAMES" ]; then
            for crate in $(echo "$PACKAGE_NAMES" | jq -r '.[]'); do
              CRATE_VERSION=$(cargo metadata --format-version 1 --no-deps | jq -r ".packages[] | select(.name == \"$crate\") | .version")
              if [[ "$CRATE_VERSION" != "$VERSION" ]]; then
                echo "Version mismatch for $crate: expected $VERSION, found $CRATE_VERSION"
                exit 1
              fi
            done
          else
            echo "No PACKAGE_NAMES configured, skipping version check"
          fi

      - name: Run tests
        if: needs.determine-release-type.outputs.skip-tests != 'true'
        run: cargo test --all-features --workspace

      - name: Publish to crates.io (Dry Run)
        if: needs.determine-release-type.outputs.dry-run == 'true'
        env:
          INDEPENDENT: ${{ vars.CRATE_PUBLISH_ORDER_INDEPENDENT || '[]' }}
          DEPENDENT: ${{ vars.CRATE_PUBLISH_ORDER_DEPENDENT || '[]' }}
        run: |
          echo "::warning::DRY RUN MODE - Would publish these packages in dependency order:"
          INDEPENDENT_COUNT=$(echo "$INDEPENDENT" | jq 'length')
          DEPENDENT_COUNT=$(echo "$DEPENDENT" | jq 'length')

          if [ "$INDEPENDENT_COUNT" -gt 0 ]; then
            echo "First batch (independent): $(echo "$INDEPENDENT" | jq -r 'join(", ")')"
          fi
          if [ "$DEPENDENT_COUNT" -gt 0 ]; then
            echo "Second batch (dependent): $(echo "$DEPENDENT" | jq -r 'join(", ")')"
          fi
          echo "::notice::No actual publishing performed"

      - name: Publish to crates.io (Production)
        if: needs.determine-release-type.outputs.dry-run != 'true'
        env:
          CARGO_REGISTRY_TOKEN: ${{ secrets.CRATES_IO_TOKEN }}
          INDEPENDENT: ${{ vars.CRATE_PUBLISH_ORDER_INDEPENDENT || '[]' }}
          DEPENDENT: ${{ vars.CRATE_PUBLISH_ORDER_DEPENDENT || '[]' }}
        run: |
          echo "::notice::Publishing packages to crates.io in dependency order..."

          INDEPENDENT_COUNT=$(echo "$INDEPENDENT" | jq 'length')
          DEPENDENT_COUNT=$(echo "$DEPENDENT" | jq 'length')

          if [ "$INDEPENDENT_COUNT" -gt 0 ]; then
            echo "::group::Publishing independent crates"
            for crate in $(echo "$INDEPENDENT" | jq -r '.[]'); do
              cargo publish -p "$crate" &
            done
            wait
            echo "::endgroup::"

            echo "::notice::Waiting for crates.io to index first batch..."
            sleep 60
          fi

          if [ "$DEPENDENT_COUNT" -gt 0 ]; then
            echo "::group::Publishing dependent crates"
            for crate in $(echo "$DEPENDENT" | jq -r '.[]'); do
              cargo publish -p "$crate"
            done
            echo "::endgroup::"

            echo "::notice::Waiting for crates.io to index second batch..."
            sleep 60
          fi

          echo "::notice::All packages published successfully!"

  release-cli:
    name: Release CLI
    needs: determine-release-type
    if: needs.determine-release-type.outputs.release-cli == 'true'
    uses: ./.github/workflows/release-cli.yml
    with:
      version: ${{ needs.determine-release-type.outputs.version }}
      dry-run: ${{ needs.determine-release-type.outputs.dry-run == 'true' }}
    secrets: inherit

  release-success:
    name: Release Success
    if: always()
    needs: [determine-release-type, release-libraries, release-cli]
    runs-on: ubuntu-latest
    steps:
      - name: Check release status
        run: |
          echo "Release type determination: ${{ needs.determine-release-type.result }}"
          echo "Library release: ${{ needs.release-libraries.result }}"
          echo "CLI release: ${{ needs.release-cli.result }}"

          if [[ "${{ needs.determine-release-type.outputs.release-libraries }}" == "true" ]] && [[ "${{ needs.release-libraries.result }}" != "success" ]]; then
            echo "::error::Library release failed"
            exit 1
          fi

              if [[ "${{ needs.determine-release-type.outputs.release-cli }}" == "true" ]]; then
                if [[ "${{ needs.release-cli.result }}" == "success" ]]; then
                  echo "CLI release: all builds succeeded"
                else
                  echo "::warning::Some CLI builds failed (see release-cli job for details). Release was still created with successful artifacts."
                fi
              fi

              echo "::notice::Release v${{ needs.determine-release-type.outputs.version }} completed successfully"