BazelClient.kt

package com.bazel_diff.bazel

import com.bazel_diff.log.Logger
import java.util.Calendar
import org.koin.core.component.KoinComponent
import org.koin.core.component.inject

class BazelClient(
    private val useCquery: Boolean,
    private val cqueryExpression: String?,
    private val fineGrainedHashExternalRepos: Set<String>,
    private val excludeExternalTargets: Boolean,
) : KoinComponent {
  private val logger: Logger by inject()
  private val queryService: BazelQueryService by inject()
  private val bazelModService: BazelModService by inject()

  suspend fun queryAllTargets(): List<BazelTarget> {
    val queryEpoch = Calendar.getInstance().getTimeInMillis()

    // Skip //external:all-targets when explicitly excluded or when Bzlmod is enabled (//external
    // not
    // available).
    val repoTargetsQuery =
        if (excludeExternalTargets || bazelModService.isBzlmodEnabled) {
          emptyList()
        } else {
          listOf("//external:all-targets")
        }

    // When Bzlmod is enabled and Bazel 8.6.0+ is available, query bzlmod-managed external repo
    // definitions via `bazel mod show_repo --output=streamed_proto`. This creates synthetic
    // //external:* targets from Build.Repository protos, enabling fine-grained hashing of
    // bzlmod dependencies.
    val bzlmodRepoTargets =
        if (bazelModService.isBzlmodEnabled && queryService.canUseBzlmodShowRepo) {
          logger.i { "Querying bzlmod-managed external repos via mod show_repo" }
          queryService.queryBzlmodRepos()
        } else {
          emptyList()
        }

    val targets =
        if (useCquery) {
          // Explicitly listing external repos here sometimes causes issues mentioned at
          // https://bazel.build/query/cquery#recursive-target-patterns. Hence, we query all
          // dependencies with `deps`
          // instead. However, we still need to append all "//external:*" targets because
          // fine-grained hash
          // computation depends on hashing of source files in external repos as well, which is
          // limited to repos
          // explicitly mentioned in `fineGrainedHashExternalRepos` flag. Therefore, for any repos
          // not mentioned there
          // we are still relying on the repo-generation target under `//external` to compute the
          // hash.
          //
          // In addition, we must include all source dependencies in this query in order for them to
          // show up in
          // `configuredRuleInput`. Hence, one must not filter them out with `kind(rule, deps(..))`.
          val expression = cqueryExpression ?: "deps(//...:all-targets)"
          val mainTargets = queryService.query(expression, useCquery = true)
          val repoTargets =
              if (repoTargetsQuery.isNotEmpty()) {
                queryService.query(repoTargetsQuery.joinToString(" + ") { "'$it'" })
              } else {
                emptyList()
              }
          (mainTargets + repoTargets).distinctBy { it.name }
        } else {
          val buildTargetsQuery =
              listOf("//...:all-targets") +
                  fineGrainedHashExternalRepos.map { "$it//...:all-targets" }
          queryService.query((repoTargetsQuery + buildTargetsQuery).joinToString(" + ") { "'$it'" })
        }
    val allTargets = (targets + bzlmodRepoTargets).distinctBy { it.name }
    val queryDuration = Calendar.getInstance().getTimeInMillis() - queryEpoch
    logger.i { "All targets queried in $queryDuration" }
    return allTargets
  }
}