releases.yml

name: Update releases.json

on:
  workflow_run:
    workflows: ["build"]
    types: [completed]
  release:
    types: [published, unpublished, created, edited, deleted, prereleased]

permissions:
  contents: write

jobs:
  update-json:
    if: |
      github.event_name != 'workflow_run' ||
      github.event.workflow_run.conclusion == 'success'

    runs-on: ubuntu-latest

    steps:
      - name: Checkout gh-pages
        uses: actions/checkout@v4
        with:
          ref: gh-pages
        continue-on-error: true

      - name: Wait for GitHub API consistency (release events)
        if: github.event_name == 'release'
        env:
          REPO: ${{ github.repository }}
          ACTION: ${{ github.event.action }}
          TARGET_ID: ${{ github.event.release.id }}
          TARGET_NAME: ${{ github.event.release.name }}
        run: |
          set -e
          echo "Release action: $ACTION"
          echo "Target release id: $TARGET_ID"
          max=10
          delay=6
          check() {
            curl -s https://api.github.com/repos/$REPO/releases
          }
          for iter in $(seq 1 $max); do
            case "$ACTION" in
              created)
                echo "Release created (draft). No API wait needed."
                exit 0
                ;;
              published|prereleased)
                if check | jq "any(.[]; .id == $TARGET_ID)"; then
                  echo "Release appeared in API"
                  exit 0
                fi
                ;;
              deleted)
                if ! check | jq "any(.[]; .id == $TARGET_ID)"; then
                  echo "Release disappeared from API"
                  exit 0
                fi
                ;;
              unpublished)
                if check | jq "any(.[]; .id == $TARGET_ID and .draft == true)"; then
                  echo "Release is now draft"
                  exit 0
                fi
                ;;
              edited)
                if check | jq "any(.[]; .id == $TARGET_ID and .name == \"$TARGET_NAME\")"; then
                  echo "Release updated"
                  exit 0
                fi
                ;;
              *)
                echo "No consistency wait needed for action: $ACTION"
                exit 0
                ;;
            esac
            echo "Retry $iter/$max..."
            sleep "$delay"
          done
          echo "WARNING: API consistency timeout for action $ACTION"
    
      - name: Save FULL releases.json
        env:
          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
          OWNER: ${{ github.repository_owner }}
          REPO: ${{ github.event.repository.name }}
        run: |
          curl -s \
            -H "Authorization: Bearer $GH_TOKEN" \
            -H "Accept: application/vnd.github+json" \
            https://api.github.com/repos/$OWNER/$REPO/releases \
          > releases.json

      - name: Generate releases_BRANCH.json
        env:
          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
          OWNER: ${{ github.repository_owner }}
          REPO: ${{ github.event.repository.name }}
        run: |
          curl -s \
            -H "Authorization: Bearer $GH_TOKEN" \
            -H "Accept: application/vnd.github+json" \
            https://api.github.com/repos/$OWNER/$REPO/releases \
          | jq '
            def normalize_release:
              {
                id: .id,
                version: (.tag_name | sub("^v"; "")),
                tag: .tag_name,
                name: .name,
                draft: .draft,
                prerelease: .prerelease,
                created_at: .created_at,
                published_at: .published_at,
                url: .html_url,
                assets: (
                  .assets | map({
                    id: .id,
                    name: .name,
                    size: .size,
                    content_type: .content_type,
                    browser_download_url: .browser_download_url
                  })
                )
              };
            sort_by(.created_at) | reverse
            | {
                zap1: (
                  map(select(.draft == false))
                  | map(select(.name | startswith("zapret ")))
                  | .[0:20]
                  | {
                      generated_at: (now | todate),
                      releases: map(normalize_release)
                    }
                ),
                zap2: (
                  map(select(.draft == false))
                  | map(select(.name | startswith("zapret2 ")))
                  | .[0:20]
                  | {
                      generated_at: (now | todate),
                      releases: map(normalize_release)
                    }
                )
              }
          ' \
          | tee \
            >(jq '.zap1' > releases_zap1.json) \
            >(jq '.zap2' > releases_zap2.json)

      - name: Generate releases_BRANCH_ARCH.json
        run: |
          BRANCHES=("zap1" "zap2")
          for ARCH in $(jq -r '.[] | .assets[].name | capture("^[^_]+_[^_]+_(?<arch>.+)\\.zip$").arch' releases.json | sort -u); do
            for BRANCH in "${BRANCHES[@]}"; do
              if [ "$BRANCH" == "zap1" ]; then
                PREFIX="zapret "
              else
                PREFIX="zapret2 "
              fi
              jq --arg prefix "$PREFIX" --arg arch "$ARCH" '
                sort_by(.created_at) | reverse
                | map(select(.draft == false))
                | map(select(.name | startswith($prefix)))
                | .[0:20]
                | map(
                    . as $release
                    | {
                        tag: $release.tag_name,
                        name: $release.name,
                        prerelease: $release.prerelease,
                        created_at: $release.created_at,
                        updated_at: $release.updated_at,
                        published_at: $release.published_at,
                        url: $release.html_url,
                        assets: ($release.assets | map(select(.name | test("_\($arch)\\.zip$"))))
                      }
                  )
                | { generated_at: (now | todate), releases: . }
              ' releases.json > "releases_${BRANCH}_${ARCH}.json"
            done
          done

      - name: Commit and push ALL releases.json
        run: |
          mkdir -p releases
          mv releases*.json releases/
          git config user.name "github-actions"
          git config user.email "github-actions@github.com"
          git checkout -B gh-pages
          git add releases/*
          git commit -m "Update releases" || exit 0
          git push origin gh-pages