dockerhub-release-matrix.yml

name: Release all major versions on Dockerhub

on:
  push:
    branches:
      - develop
      - release/*
    paths:
      - ansible/postgres_release.yml
  workflow_dispatch:

permissions:
  contents: read
  id-token: write

jobs:
  prepare:
    runs-on: blacksmith-4vcpu-ubuntu-2404
    outputs:
      matrix_config: ${{ steps.set-matrix.outputs.matrix_config }}
    steps:
      - name: Checkout Repo
        uses: actions/checkout@v7.0.1
      - uses: $/.github/actions/install-nix
      - name: Generate build matrix
        id: set-matrix
        run: |
          nix run nixpkgs#nushell -- -c 'let versions = (open ansible/vars.yml | get postgres_major)
          let base_matrix = ($versions | each { |ver|
            let version = ($ver | str trim)
            let dockerfile = $"Dockerfile-($version)"
            if ($dockerfile | path exists) {
              {
                version: $version,
                dockerfile: $dockerfile,
                target: "production"
              }
            } else {
              null
            }
          } | compact)

          # Discover multigres variants by checking for matching targets in Dockerfile-multigres
          let multigres_matrix = ($versions | each { |ver|
            let version = ($ver | str trim)
            let mg_version = $"multigres-($version)"
            let mg_dockerfile = "Dockerfile-multigres"
            let mg_target = $"variant-($version)"
            if ($mg_dockerfile | path exists) and (open --raw $mg_dockerfile | str contains $"AS ($mg_target)") {
              {
                version: $mg_version,
                dockerfile: $mg_dockerfile,
                target: $mg_target
              }
            } else {
              null
            }
          } | compact)

          let matrix = ($base_matrix | append $multigres_matrix)

          let matrix_config = {
            include: $matrix
          }

          $"matrix_config=($matrix_config | to json -r)" | save --append $env.GITHUB_OUTPUT'
  build:
    needs: prepare
    strategy:
      matrix: ${{ fromJson(needs.prepare.outputs.matrix_config) }}
    runs-on: large-linux-x86
    outputs:
      build_args: ${{ steps.args.outputs.result }}
    steps:
      - name: Checkout Repo
        uses: actions/checkout@v7.0.1
      - uses: $/.github/actions/install-nix
      - name: Set PostgreSQL version environment variable
        run: echo "POSTGRES_MAJOR_VERSION=${{ matrix.version }}" >> $GITHUB_ENV
      
      - id: args
        run: |
          nix run nixpkgs#nushell -- -c '
            open ansible/vars.yml 
            | items { |key value| {name: $key, item: $value} } 
            | where { |it| ($it.item | describe) == "string" } 
            | each { |it| $"($it.name)=($it.item)" } 
            | str join "\n" 
            | save --append $env.GITHUB_OUTPUT
          '    
  build_release_image:
    needs: [prepare, build]
    strategy:
      matrix:
        postgres: ${{ fromJson(needs.prepare.outputs.matrix_config).include }}
        arch: [amd64, arm64]
    runs-on: ${{ matrix.arch == 'amd64' && 'large-linux-x86' || 'large-linux-arm' }}
    timeout-minutes: 180
    steps:
      - name: Checkout Repo
        uses: actions/checkout@v7.0.1
      - uses: $/.github/actions/install-nix
      - run: docker context create builders
      - uses: docker/setup-buildx-action@v4.4.1
        with:
          endpoint: builders
      - uses: docker/login-action@v4.6.0
        with:
          username: ${{ secrets.DOCKER_USERNAME }}
          password: ${{ secrets.DOCKER_PASSWORD }}
      - name: Get image tag
        id: image
        run: |
          if [[ "${{ matrix.arch }}" == "arm64" ]]; then
            pg_version=$(nix run nixpkgs#nushell -- -c '
              let version = "${{ matrix.postgres.version }}"
              let is_multigres = ($version | str starts-with "multigres-")
              let base_version = if $is_multigres { $version | str replace "multigres-" "" } else { $version }
              let release_key = if ($base_version | str contains "orioledb") {
                $"postgresorioledb-17"
              } else {
                $"postgres($base_version)"
              }
              let base_tag = (open ansible/postgres_release.yml | get postgres_release | get $release_key | str trim)
              if $is_multigres { $"($base_tag)-multigres" } else { $base_tag }
            ')
            echo "pg_version=supabase/postgres:$pg_version" >> $GITHUB_OUTPUT
          else
            pg_version=$(nix run nixpkgs#nushell -- -c '
              let version = "${{ matrix.postgres.version }}"
              let is_multigres = ($version | str starts-with "multigres-")
              let base_version = if $is_multigres { $version | str replace "multigres-" "" } else { $version }
              let release_key = if ($base_version | str contains "orioledb") {
                $"postgresorioledb-17"
              } else {
                $"postgres($base_version)"
              }
              let base_tag = (open ansible/postgres_release.yml | get postgres_release | get $release_key | str trim)
              if $is_multigres { $"($base_tag)-multigres" } else { $base_tag }
            ')
            echo "pg_version=supabase/postgres:$pg_version" >> $GITHUB_OUTPUT
          fi
      - id: build
        uses: docker/build-push-action@v7.4.0
        with:
          push: true
          build-args: |
            ${{ needs.build.outputs.build_args }}
          target: ${{ matrix.postgres.target }}
          tags: ${{ steps.image.outputs.pg_version }}_${{ matrix.arch }}
          platforms: linux/${{ matrix.arch }}
          cache-from: type=gha,scope=${{ github.ref_name }}-latest-${{ matrix.arch }}
          cache-to: type=gha,mode=max,scope=${{ github.ref_name }}-latest-${{ matrix.arch }}
          file: ${{ matrix.postgres.dockerfile }}
  merge_manifest:
    needs: [prepare, build, build_release_image]
    strategy:
      matrix:
        include: ${{ fromJson(needs.prepare.outputs.matrix_config).include }}
    runs-on: large-linux-x86
    steps:
      - name: Checkout Repo
        uses: actions/checkout@v7.0.1
      - uses: $/.github/actions/install-nix
      - uses: docker/setup-buildx-action@v4.4.1
      - uses: docker/login-action@v4.6.0
        with:
          username: ${{ secrets.DOCKER_USERNAME }}
          password: ${{ secrets.DOCKER_PASSWORD }}
      - name: Get image tag
        id: get_version
        run: |
          nix run nixpkgs#nushell -- -c '
            let version = "${{ matrix.version }}"
            let is_multigres = ($version | str starts-with "multigres-")
            let base_version = if $is_multigres { $version | str replace "multigres-" "" } else { $version }
            let release_key = if ($base_version | str contains "orioledb") {
              $"postgresorioledb-17"
            } else {
              $"postgres($base_version)"
            }
            let base_tag = (open ansible/postgres_release.yml | get postgres_release | get $release_key | str trim)
            let pg_version = if $is_multigres { $"($base_tag)-multigres" } else { $base_tag }
            $"pg_version=supabase/postgres:($pg_version)" | save --append $env.GITHUB_OUTPUT
          '
      - name: Output version
        id: output_version
        run: |
          echo "result=${{ steps.get_version.outputs.pg_version }}" >> $GITHUB_OUTPUT
      - name: Collect versions
        id: collect_versions
        run: |
          echo "${{ steps.output_version.outputs.result }}" >> results.txt  # Append results
      - name: Upload Results Artifact
        uses: actions/upload-artifact@v7.0.2
        with:
          name: merge_results-${{ matrix.version }}
          path: results.txt
          if-no-files-found: warn
      - name: Merge multi-arch manifests
        run: |
          docker buildx imagetools create -t ${{ steps.get_version.outputs.pg_version }} \
          ${{ steps.get_version.outputs.pg_version }}_amd64 \
          ${{ steps.get_version.outputs.pg_version }}_arm64
  combine_results:
    needs: [prepare, merge_manifest]
    runs-on: large-linux-x86
    steps:
      - name: Checkout Repo
        uses: actions/checkout@v7.0.1
      - uses: $/.github/actions/install-nix

      - name: Debug Input from Prepare
        run: |
          echo "Raw matrix_config output:"
          echo "${{ needs.prepare.outputs.matrix_config }}"
      - name: Get Versions from Matrix Config
        id: get_versions
        run: |
          nix run nixpkgs#nushell -- -c '
            # Parse the matrix configuration directly
            let matrix_config = (${{ toJson(needs.prepare.outputs.matrix_config) }} | from json)
      
            # Get versions directly from include array
            let versions = ($matrix_config.include | get version)
      
            echo "Versions: $versions"
      
            # Convert the versions to a comma-separated string
            let versions_str = ($versions | str join ",")
            $"versions=$versions_str" | save --append $env.GITHUB_ENV
          '
      - name: Download Results Artifacts
        uses: actions/download-artifact@v8.0.2
        with:
          pattern: merge_results-*
      - name: Combine Results
        id: combine
        run: |
          nix run nixpkgs#nushell -- -c '
            # Get all results files and process them in one go
            let files = (ls **/results.txt | get name)
            echo $"Found files: ($files)"
            
            let matrix = {
              include: (
                $files
                | each { |file| open $file }          # Open each file
                | each { |content| $content | lines }  # Split into lines
                | flatten                             # Flatten the nested lists
                | where { |line| $line != "" }        # Filter empty lines
                | each { |line| 
                    # Extract just the version part after the last colon
                    let version = ($line | parse "supabase/postgres:{version}" | get version.0)
                    {version: $version}
                }
              )
            }
            
            let json_output = ($matrix | to json -r)  # -r for raw output
            echo $"Debug output: ($json_output)"
            
            $"matrix=($json_output)" | save --append $env.GITHUB_OUTPUT
          '
      - name: Debug Combined Results
        run: |
          echo "Combined Results: '${{ steps.combine.outputs.matrix }}'"
    outputs:
      matrix: ${{ steps.combine.outputs.matrix }}
  publish:
      needs: combine_results
      permissions:
        contents: read
        packages: write
        id-token: write
      strategy:
        matrix: ${{ fromJson(needs.combine_results.outputs.matrix) }}
      uses: $/.github/workflows/mirror.yml
      with:
        version: ${{ matrix.version }}
      secrets: inherit