MODULE.bazel

module(
    name = "dashql",
    version = "0.1.0",
)

# Rules for C/C++ (cc_library, cc_test, etc.)
bazel_dep(name = "rules_cc", version = "0.2.17")

# Emscripten SDK
bazel_dep(name = "emsdk", version = "5.0.5")

# Rules for Rust
bazel_dep(name = "rules_rust", version = "0.69.0")

# wasm-bindgen extension: provides rust_wasm_bindgen (Rust cdylib -> JS glue + .wasm) for
# the vendored UMAP crates (//packages/dashql-umap). Its default toolchain bundles
# wasm-bindgen-cli 0.2.105, which is why the vendored crates pin wasm-bindgen "=0.2.105"
# (the CLI and the crate must match exactly). The extension's own module extension +
# default_wasm_bindgen_toolchain registration are pulled in transitively.
bazel_dep(name = "rules_rust_wasm_bindgen", version = "0.69.0")

# Patch rules_rust to fix Rust coverage under Bazel 8/9: collect_coverage.sh
# explicitly clears RUNFILES_DIR before exec-ing the LCOV merger, which caused
# collect_coverage.rs to resolve the wrong test binary path and produce an empty
# coverage.dat.  The patch derives the bin dir from COVERAGE_DIR instead.
single_version_override(
    module_name = "rules_rust",
    version = "0.69.0",
    patches = ["//bazel/patches:rules_rust_collect_coverage_fix.patch"],
    patch_strip = 1,
)

bazel_dep(name = "platforms", version = "1.0.0")
bazel_dep(name = "rules_foreign_cc", version = "0.15.1")
bazel_dep(name = "googletest", version = "1.18.0")
bazel_dep(name = "gflags", version = "2.3.1")

# JS/TS/Jest (aspect rules) — used by packages/dashql-core/api
bazel_dep(name = "aspect_bazel_lib", version = "2.22.5")
bazel_dep(name = "aspect_rules_js", version = "2.9.2")
bazel_dep(name = "aspect_rules_ts", version = "3.8.8")
bazel_dep(name = "aspect_rules_jest", version = "0.25.2")

bazel_dep(name = "rules_nodejs", version = "6.7.3")
bazel_dep(name = "rules_shell", version = "0.7.1")
bazel_dep(name = "rules_python", version = "1.9.0")

# OCI container image rules (packages/hyper-docker)
bazel_dep(name = "rules_oci", version = "2.3.0")
bazel_dep(name = "rules_pkg", version = "1.2.0")

# Node.js toolchain (for app_bundle postprocess script).
node = use_extension("@rules_nodejs//nodejs:extensions.bzl", "node")
node.toolchain(node_version = "24.4.1")
use_repo(node, "nodejs_toolchains")

register_toolchains("@nodejs_toolchains//:all")

# Protobuf: proto_library (rules_proto) + custom plugins (rules_proto_grpc) for protoc + protoc-gen-es
bazel_dep(name = "rules_proto", version = "7.1.0")
bazel_dep(name = "rules_proto_grpc", version = "5.8.0")
bazel_dep(name = "protobuf", version = "35.1")

# protobuf 34.1 -> rules_kotlin 2.2.2 -> rules_android 0.6.4.
# rules_android 0.6.4 has two issues on Bazel 9:
#   1. Its android_sdk_repository_extension creates an @androidsdk repo whose helper.bzl
#      references @local_config_platform which is not visible in bzlmod (fixed in 0.7.1 by
#      upgrading rules_cc + rules_java; see bazelbuild/rules_android#374).
#   2. It pulls in rules_go 0.51.0-rc2 which uses CcInfo as a built-in symbol removed in
#      newer rules_cc (fixed in rules_go >= 0.52.0).
# Override both to latest stable versions.
single_version_override(
    module_name = "rules_android",
    version = "0.7.1",
)

single_version_override(
    module_name = "rules_go",
    version = "0.60.0",
)

# copy_to_directory toolchain (assemble src + FlatBuffer TS into one tree for SWC)
bazel_lib_toolchains = use_extension("@aspect_bazel_lib//lib:extensions.bzl", "toolchains")
bazel_lib_toolchains.copy_to_directory()
use_repo(bazel_lib_toolchains, "copy_to_directory_toolchains")

register_toolchains("@copy_to_directory_toolchains//:all")

# npm deps from pnpm lockfile at repo root. Single source: root package.json + workspace packages; run "pnpm install" to update.
npm = use_extension("@aspect_rules_js//npm:extensions.bzl", "npm", dev_dependency = True)
npm.npm_translate_lock(
    name = "npm",
    data = [
        "//:package.json",
    ],
    pnpm_lock = "//:pnpm-lock.yaml",
    patches = {
        "d3-brush@3.0.0": ["//bazel/patches:d3-brush@3.0.0.patch"],
    },
    patch_args = {
        "d3-brush@3.0.0": ["-p1"],
    },
    verify_node_modules_ignored = "//:.bazelignore",
    # Hoist platform-specific native binaries so they can be found via Node.js module resolution
    # (traversing up to the root node_modules). In aspect_rules_js v3, optional platform packages
    # are linked inside each package's store via select(), but the select() may not resolve in
    # the exec configuration (ST-<hash>) used by js_run_binary. Hoisting ensures the packages
    # are always available at the top-level node_modules for the CI platforms.
    public_hoist_packages = {
        # rolldown native binaries (used by Vite 8)
        "@rolldown/binding-darwin-arm64": [""],
        "@rolldown/binding-darwin-x64": [""],
        "@rolldown/binding-linux-x64-gnu": [""],
        "@rolldown/binding-linux-arm64-gnu": [""],
        # lightningcss native binaries (used by Vite 8 for CSS minification)
        "lightningcss-darwin-arm64": [""],
        "lightningcss-darwin-x64": [""],
        "lightningcss-linux-x64-gnu": [""],
        "lightningcss-linux-arm64-gnu": [""],
    },
)
use_repo(npm, "npm")

core_deps = use_extension("//bazel:core_dependencies.bzl", "dashql_core_dependencies")

use_repo(
    core_deps,
    "ankerl_unordered_dense",
    "apache_arrow",
    "binaryen",
    "bison_src",
    "c4core",
    "com_google_benchmark",
    "com_google_flatbuffers",
    "duckdb_cli_linux_amd64",
    "duckdb_cli_osx",
    "duckdb_source",
    "flex_src",
    "m4_src",
    "rapidjson",
    "rapidyaml",
    "wabt",
)

# data.dashql.app test datasets: one hash-pinned http_file per source, declared from
# the DATASETS list in //packages/dashql-data:datasets.bzl (single source of truth).
# When adding/removing a dataset source, update the use_repo list below to match.
dashql_datasets = use_extension("//packages/dashql-data:deps.bzl", "dashql_datasets")
use_repo(
    dashql_datasets,
    "dataset_vega_cars_cars",
    # Vendored DuckDB tpch extension, one per exec platform (backs the tpch-* datasets).
    "tpch_extension_linux_amd64",
    "tpch_extension_linux_arm64",
    "tpch_extension_osx_amd64",
    "tpch_extension_osx_arm64",
)

# Emscripten binaries (downloaded per-platform; default version is the latest bundled with emsdk 5.0.4).
emsdk_ext = use_extension("@emsdk//:emscripten_deps.bzl", "emscripten_deps")
use_repo(
    emsdk_ext,
    "emscripten_bin_linux",
    "emscripten_bin_linux_arm64",
    "emscripten_bin_mac",
    "emscripten_bin_mac_arm64",
)

rust = use_extension("@rules_rust//rust:extensions.bzl", "rust")
rust.toolchain(
    edition = "2021",
    # Register both macOS target triples so the universal-binary slices
    # (mac_app_aarch64 / mac_app_x86_64) can be cross-compiled regardless of the
    # runner's host arch -- macos-15 runners are Apple Silicon (aarch64 host), so
    # building the x86_64 slice is a cross-compile that needs x86_64-apple-darwin
    # registered as a target toolchain.
    # wasm32-unknown-unknown is the target for the vendored UMAP crates
    # (//packages/dashql-umap), compiled to a cdylib and run through rust_wasm_bindgen.
    extra_target_triples = [
        "aarch64-apple-darwin",
        "x86_64-apple-darwin",
        "wasm32-unknown-unknown",
    ],
    versions = ["1.93.1"],
)
use_repo(rust, "rust_toolchains")

register_toolchains("@rust_toolchains//:all")

# App version (git describe -> version.env for Vite genrules in dashql-app).
app_version = use_extension("//packages/dashql-app:bazel/version.bzl", "dashql_app_version_ext")
use_repo(app_version, "dashql_app_version")

# Native crate universe (dashql-native, dashql-pack -- no WASM).
# Root workspace at Cargo.toml with members pointing downward into packages/.
# Run CARGO_BAZEL_REPIN=1 bazel build @crates//:all after changing root Cargo.toml or Cargo.lock.
# Native crate universe: aarch64 + x86_64 macOS (for universal binary) + Linux.
# After changing triples, repin: CARGO_BAZEL_REPIN=1 bazel build @crates//:all
native_crate = use_extension("@rules_rust//crate_universe:extensions.bzl", "crate", isolate = True)
native_crate.from_cargo(
    name = "crates",
    cargo_lockfile = "//:Cargo.lock",
    manifests = ["//:Cargo.toml"],
    supported_platform_triples = [
        "aarch64-apple-darwin",
        "x86_64-apple-darwin",
        "x86_64-unknown-linux-gnu",
    ],
)

# WASM crate universe for the vendored UMAP crates (//packages/dashql-umap). Separate
# from the native "crates" universe (isolate = True) so its wasm-only deps
# (wasm-bindgen, js-sys, getrandom/wasm_js, ...) never leak into the native binaries,
# and pinned to the single wasm32-unknown-unknown triple.
# After changing packages/dashql-umap/Cargo.{toml,lock}, repin:
#   CARGO_BAZEL_REPIN=1 bazel build @umap_crates//:all
wasm_crate = use_extension("@rules_rust//crate_universe:extensions.bzl", "crate", isolate = True)
wasm_crate.from_cargo(
    name = "umap_crates",
    cargo_lockfile = "//packages/dashql-umap:Cargo.lock",
    manifests = ["//packages/dashql-umap:Cargo.toml"],
    # wasm32 is the actual compile target, but the host triples MUST also be listed:
    # cargo build scripts (e.g. matrixmultiply's, via autocfg) run in the exec/host
    # configuration, and crate_universe marks host-side helper crates
    # @@platforms//:incompatible if no host triple is declared.
    supported_platform_triples = [
        "wasm32-unknown-unknown",
        "aarch64-apple-darwin",
        "x86_64-apple-darwin",
        "x86_64-unknown-linux-gnu",
    ],
)
use_repo(wasm_crate, "umap_crates")

# Tauri plugin crates that ship ACL permission TOML files.
# Update version suffixes in use_repo below when upgrading tauri plugin dependencies, then repin:
#   CARGO_BAZEL_REPIN=1 bazel build @crates//:all
_TAURI_PLUGINS = [
    "tauri-plugin-deep-link",
    "tauri-plugin-dialog",
    "tauri-plugin-fs",
    "tauri-plugin-http",
    "tauri-plugin-log",
    "tauri-plugin-os",
    "tauri-plugin-process",
    "tauri-plugin-shell",
    "tauri-plugin-updater",
]

# Filegroup added to every tauri plugin crate so tauri-aclgen can read
# permission TOML files as proper Bazel inputs (avoids sandbox path issues).
_TAURI_PERMISSION_FILEGROUP = """
filegroup(
    name = "permission_files",
    srcs = glob(["permissions/**/*.toml"]),
    visibility = ["//visibility:public"],
)
"""

# Export permission TOML files from tauri plugin crates.
[native_crate.annotation(
    crate = plugin_name,
    additive_build_file_content = _TAURI_PERMISSION_FILEGROUP,
) for plugin_name in _TAURI_PLUGINS]

use_repo(
    native_crate,
    "crates",
    # Individual plugin crate repos for permission file access by tauri-aclgen.
    "crates__tauri-plugin-deep-link-2.4.9",
    "crates__tauri-plugin-dialog-2.7.1",
    "crates__tauri-plugin-fs-2.5.1",
    "crates__tauri-plugin-http-2.5.9",
    "crates__tauri-plugin-log-2.8.0",
    "crates__tauri-plugin-os-2.3.2",
    "crates__tauri-plugin-process-2.3.1",
    "crates__tauri-plugin-shell-2.3.5",
    "crates__tauri-plugin-updater-2.10.1",
)

# WASM build: use emscripten toolchain (standalone mode, same .wasm output as WASI SDK).
register_toolchains("@emsdk//emscripten_toolchain:all")

# Execution platforms: host first (default for non-wasm actions), then the neutral
# wasm_tool_exec platform used by wasm_tool exec groups in wasm_tools.bzl / rust_wasm.bzl.
# @platforms//host:host must come first so Bazel 9 (which now auto-selects the first
# registered exec platform whose toolchains all match) picks the host for regular targets
# like //proto/pb:ts_gen rather than wasm_tool_exec (which has no Node.js/shell toolchains).
register_execution_platforms(
    "@platforms//host:host",
    "//bazel/platforms:wasm_tool_exec",
)

# Pull ubi9-minimal base image for //packages/hyper-docker.
# Pin the digest for reproducible builds; update with:
#   crane digest registry.access.redhat.com/ubi9/ubi-minimal:9.7-1773939694
oci = use_extension("@rules_oci//oci:extensions.bzl", "oci")
oci.pull(
    name = "ubi9_minimal",
    image = "registry.access.redhat.com/ubi9/ubi-minimal:9.7-1773939694",
    # renovate: depName=registry.access.redhat.com/ubi9/ubi-minimal
    digest = "sha256:5b74fce9d6e629942a0c6dc0f546c193e70d7f974d999a48c948c53dd3d36362",
    platforms = ["linux/amd64"],
)
use_repo(oci, "ubi9_minimal", "ubi9_minimal_linux_amd64")

# Native Tableau Hyper API C++ distributions for //packages/hyper-api and
# //packages/hyper-docker.
tableauhyperapi = use_extension("//bazel:external_tableauhyperapi.bzl", "tableauhyperapi_ext")
use_repo(
    tableauhyperapi,
    "tableauhyperapi_cxx_linux_x86_64",
    "tableauhyperapi_cxx_macos_arm64",
    "tableauhyperapi_cxx_macos_x86_64",
)

# hyperd Docker image: resolves the Linux x86_64 hyperd binary (C++ archive,
# or HYPERD_BINARY override) and the image repo_tag. See //packages/hyper-docker.
hyperd_image = use_extension("//packages/hyper-docker:version.bzl", "hyperd_image_ext")
use_repo(hyperd_image, "hyperd_image")

# Hedron's Compile Commands Extractor for Bazel
# https://github.com/hedronvision/bazel-compile-commands-extractor
bazel_dep(name = "hedron_compile_commands", dev_dependency = True)
git_override(
    module_name = "hedron_compile_commands",
    commit = "7fe1eab26d2b8eeb5e1c6a2f38bddb001e3f9696",
    remote = "https://github.com/hedronvision/bazel-compile-commands-extractor.git",
)