clean-architecture-backend-template/.github/workflows/ci-quality-gates.yml

name: ci-quality-gates

on:
  pull_request:
  push:
    branches: ["main"]
  workflow_dispatch:

permissions:
  contents: read

concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true

env:
  TESTCONTAINERS_REUSE_ENABLE: "false"

jobs:
  quality-gates:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # actions/checkout@v4.2.2
      - name: Validate Gradle wrapper
        id: gradle-wrapper-validation
        uses: gradle/actions/wrapper-validation@3f131e8634966bd73d06cc69884922b02e6faf92 # gradle/actions@v6
      - name: Require the committed public-path security baseline
        run: |
          set -euo pipefail
          readonly snapshot='docs/security/public-paths-snapshot.txt'
          if [[ ! -s "${snapshot}" ]]; then
            echo "::error::${snapshot} is missing or empty. CI must not let verifyPublicPathSnapshot create its own first-run baseline."
            exit 1
          fi
          if ! git ls-files --error-unmatch "${snapshot}" >/dev/null 2>&1; then
            echo "::error::${snapshot} exists locally but is not committed."
            exit 1
          fi
      - uses: ./.github/actions/setup-gradle-java
      - name: Check quality, public paths, and dependency locks
        working-directory: src
        run: ./gradlew check verifyPublicPathSnapshot verifyDependencyLocks --warning-mode=fail --no-daemon --stacktrace
      # build-logic is an included build: its own suite is not reachable from the root project's
      # `check`, so the convention plugins every leaf applies shipped untested in CI. Kept as its
      # own step rather than folded into the aggregate invocation above, which
      # ConditionalTransportQualificationContractTest asserts on byte-for-byte.
      - name: Test the build-logic convention plugins
        working-directory: src
        run: ./gradlew -p build-logic test --no-daemon --stacktrace
      # Named as its own step because nothing else runs it: `check` does not depend on
      # graphqlStableTest, so the lane's required-class guard — the check that its module-boundary
      # suite has not silently stopped being discovered — protected nothing in CI. A separate step
      # keeps the aggregate invocation below byte-identical, which ConditionalTransportQualification
      # ContractTest asserts on, and the two tasks do not overlap.
      - name: Qualify the GraphQL Stable lane
        working-directory: src
        run: ./gradlew :adapter:inbound:graphql:graphqlStableTest --no-daemon --stacktrace
      - name: Qualify opt-in inbound transports without skips
        working-directory: src
        run: ./gradlew conditionalTransportQualification --no-daemon --stacktrace

  sample-off:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # actions/checkout@v4.2.2
      - name: Validate Gradle wrapper
        id: gradle-wrapper-validation
        uses: gradle/actions/wrapper-validation@3f131e8634966bd73d06cc69884922b02e6faf92 # gradle/actions@v6
      - uses: ./.github/actions/setup-gradle-java
      - name: Verify the application without the sample fixture
        working-directory: src
        run: ./gradlew :app-bootstrap:sampleOffTest verifyCleanArchitectureDependencies --no-daemon --stacktrace

  gate-matrix-lint:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # actions/checkout@v4.2.2
      - name: Verify the gate matrix against the repository
        run: bash .github/scripts/verify-gate-matrix.sh

  redis-sdk:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # actions/checkout@v4.2.2
      - name: Validate Gradle wrapper
        id: gradle-wrapper-validation
        uses: gradle/actions/wrapper-validation@3f131e8634966bd73d06cc69884922b02e6faf92 # gradle/actions@v6
      - uses: ./.github/actions/setup-gradle-java
      # Milestone A of the Redis wrapper/typed API plan: policy catalog, typed API parity,
      # permit provenance, connection isolation, and the executor guard. There is no real-server
      # lane yet — Tasks 10-17 add the contract suites that need one.
      - name: Verify the Redis SDK policy, API parity, and guardrail contracts
        working-directory: src
        run: >-
          ./gradlew
          :shared-contract:edgeRateLimitContractTest
          :adapter:outbound:cache-redis:check
          verifyCleanArchitectureDependencies
          verifyEnvKeys
          verifyPublicPathSnapshot
          verifyConfigurationPropertiesProcessor
          --no-daemon --stacktrace

  jpa-candidate-evidence:
    runs-on: ubuntu-latest
    timeout-minutes: 20
    steps:
      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # actions/checkout@v4.2.2
      - name: Validate Gradle wrapper
        id: gradle-wrapper-validation
        uses: gradle/actions/wrapper-validation@3f131e8634966bd73d06cc69884922b02e6faf92 # gradle/actions@v6
      - uses: ./.github/actions/setup-gradle-java
      - name: Produce zero-skip JPA candidate manifests
        working-directory: src
        run: >-
          ./gradlew
          :adapter:outbound:persistence-jpa:verifyJpaCandidateEvidence
          --no-daemon
          --stacktrace
      - name: Retain content-addressed JPA candidate manifests
        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # actions/upload-artifact@v7.0.1
        with:
          name: jpa-candidate-evidence-${{ github.sha }}
          path: src/adapter/outbound/persistence-jpa/build/jpa-evidence/manifests
          if-no-files-found: error
          retention-days: 14

  # Advisory only. Quarantine expiry/drift remains blocking through verifyQuarantineSunset in check.
  quarantine:
    runs-on: ubuntu-latest
    continue-on-error: true
    steps:
      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # actions/checkout@v4.2.2
      - name: Validate Gradle wrapper
        id: gradle-wrapper-validation
        uses: gradle/actions/wrapper-validation@3f131e8634966bd73d06cc69884922b02e6faf92 # gradle/actions@v6
      - uses: ./.github/actions/setup-gradle-java
      - name: Run quarantined tests as an advisory signal
        working-directory: src
        run: ./gradlew quarantineTest --no-daemon

  release-gate:
    needs:
      - quality-gates
      - sample-off
      - gate-matrix-lint
      - redis-sdk
      - jpa-candidate-evidence
    if: always()
    runs-on: ubuntu-latest
    permissions:
      contents: read
      checks: read
    steps:
      - name: Require every current blocking job to succeed
        env:
          QUALITY_RESULT: ${{ needs.quality-gates.result }}
          SAMPLE_OFF_RESULT: ${{ needs.sample-off.result }}
          MATRIX_RESULT: ${{ needs.gate-matrix-lint.result }}
          REDIS_RESULT: ${{ needs.redis-sdk.result }}
          JPA_CANDIDATE_RESULT: ${{ needs.jpa-candidate-evidence.result }}
        run: |
          set -euo pipefail
          for result in \
            "${QUALITY_RESULT}" \
            "${SAMPLE_OFF_RESULT}" \
            "${MATRIX_RESULT}" \
            "${REDIS_RESULT}" \
            "${JPA_CANDIDATE_RESULT}"; do
            if [[ "${result}" != "success" ]]; then
              echo "::error::release-gate: required job result was ${result}"
              exit 1
            fi
          done
          echo "release-gate: all current blocking quality jobs succeeded."

      # `needs` cannot reach another workflow, so every gate .github/ci-gate-matrix.yml marks
      # release_blocking outside this file was invisible here: the field was read by nothing but an
      # enum check in verify-gate-matrix.sh. filesystem-vulnerability-scan
      # (dependency-vulnerability.yml::trivy-fs) is release_blocking: true and blocks on
      # CRITICAL/HIGH and on the CISA KEV catalogue — it could be red while this job reported green
      # and nothing in the repository joined the two.
      #
      # dependency-vulnerability.yml answers the same pull_request and push-to-main triggers as this
      # workflow and trivy-fs carries no `if:` guard, so its check run always exists for this SHA.
      # That is what makes it requirable by result rather than by scheduling luck. Only `success`
      # passes: a skipped or cancelled security scan is not a scan.
      #
      # The other release_blocking gates outside this file run on triggers this job does not share
      # and so cannot be required here without changing when they run: release.yml, jpa-release.yml
      # and fileserver-release.yml answer a release tag, and object-storage-qualification.yml and
      # messaging-certification.yml answer a path filter or a schedule. That is left as a stated gap
      # rather than a silently different one.
      - name: Require the cross-workflow release-blocking checks to have succeeded
        env:
          GH_TOKEN: ${{ github.token }}
          GH_REPO: ${{ github.repository }}
          COMMIT_SHA: ${{ github.sha }}
          REQUIRED_CHECKS: trivy-fs
        run: |
          set -euo pipefail
          deadline=$(( $(date +%s) + 1800 ))
          for required in ${REQUIRED_CHECKS}; do
            while :; do
              result="$(
                gh api \
                  "repos/${GH_REPO}/commits/${COMMIT_SHA}/check-runs?check_name=${required}&per_page=100" \
                  --jq '[.check_runs[]] | sort_by(.started_at) | last
                        | if . == null then "absent none"
                          else "\(.status) \(.conclusion // "none")" end'
              )"
              check_status="${result%% *}"
              check_conclusion="${result##* }"
              if [[ "${check_status}" == "completed" ]]; then
                break
              fi
              if (( $(date +%s) >= deadline )); then
                echo "::error::release-gate: release-blocking check ${required} reported no result for ${COMMIT_SHA} (status ${check_status})"
                exit 1
              fi
              echo "release-gate: waiting for ${required} (status ${check_status})"
              sleep 30
            done
            if [[ "${check_conclusion}" != "success" ]]; then
              echo "::error::release-gate: release-blocking check ${required} concluded ${check_conclusion}"
              exit 1
            fi
            echo "release-gate: ${required} concluded success."
          done