BUILD.bazel

load("@aspect_bazel_lib//lib:copy_to_directory.bzl", "copy_to_directory")
load("@aspect_bazel_lib//lib:run_binary.bzl", "run_binary")
load("@npm//:defs.bzl", "npm_link_all_packages")
load("@npm//:prettier/package_json.bzl", prettier_bin = "bin")
load("@rules_rust//rust:defs.bzl", "rust_clippy", "rustfmt_test")
load("@rules_shell//shell:sh_binary.bzl", "sh_binary")
load("@rules_shell//shell:sh_test.bzl", "sh_test")
load("@rules_shellcheck//:def.bzl", "shellcheck_test")
load(":cargo_build.bzl", "cargo_run", "cargo_test", "cargo_vendor", "cargo_vendor_provider", "python_venv", "python_venv_provider", "uv_python_install", "uv_python_venv")

# Link all npm packages into node_modules
npm_link_all_packages(name = "node_modules")

# Prettier configuration and pnpm workspace files
exports_files([
    ".prettierrc.json",
    "package.json",
    "pnpm-lock.yaml",
    "pnpm-workspace.yaml",
])

# Files to check with prettier (root package only)
filegroup(
    name = "prettier_srcs",
    srcs = glob(
        [
            ".github/**/*.yaml",
            ".github/**/*.yml",
        ],
    ) + [
        "README.md",
        "//editors/code:prettier_srcs",
        "//playground:prettier_srcs",
    ],
)

# Prettier format check test
prettier_bin.prettier_test(
    name = "prettier_check",
    size = "small",
    args = [
        "--check",
        "--config",
        ".prettierrc.json",
        "editors",
        "playground",
        "*.md",
        ".github",
    ],
    chdir = package_name(),
    data = [
        ":node_modules/prettier",
        ":prettier_srcs",
        ".prettierrc.json",
        "//editors/code:prettier_srcs",
        "//playground:prettier_srcs",
    ],
)

# Prettier format (for fixing locally)
prettier_bin.prettier_binary(
    name = "prettier_fix",
    args = [
        "--write",
        "--config",
        ".prettierrc.json",
        "editors",
        "playground",
        "*.md",
        ".github",
    ],
    chdir = package_name(),
    data = [
        ":node_modules/prettier",
        ":prettier_srcs",
        ".prettierrc.json",
        "//editors/code:prettier_srcs",
        "//playground:prettier_srcs",
    ],
    env = {"JS_BINARY__CHDIR": "$$BUILD_WORKSPACE_DIRECTORY"},
)

# ESLint check for all TypeScript packages
# Runs ESLint on both playground and editors/code
# Usage: bazel test //:eslint_check
test_suite(
    name = "eslint_check",
    tests = [
        "//editors/code:eslint_check",
        "//playground:eslint_check",
    ],
)

# TypeScript check for all TypeScript packages
# Runs tsc --noEmit on both playground and editors/code
# Usage: bazel test //:typescript_check
test_suite(
    name = "typescript_check",
    tests = [
        "//editors/code:typescript_check",
        "//playground:typescript_check",
    ],
)

# Shellcheck test for shell scripts
shellcheck_test(
    name = "shellcheck",
    size = "small",
    data = glob([".hacking/scripts/*.sh"]),
    severity = "warning",
)

# Check that LICENSE and README.md are synced to editors/code
sh_test(
    name = "check_files_match",
    size = "small",
    srcs = [".hacking/scripts/check_files_match.sh"],
    data = [
        "LICENSE",
        "README.md",
        "//editors/code:LICENSE",
        "//editors/code:README.md",
    ],
)

# Ratchet check for GitHub Actions version pinning
sh_test(
    name = "ratchet_check",
    size = "small",
    srcs = [".hacking/scripts/ratchet_check.sh"],
    data = [
        "@ratchet//:ratchet",
    ] + glob([".github/workflows/*.yml"]),
)

# Verify all pinned GitHub Actions SHAs actually exist
sh_test(
    name = "verify_action_shas",
    size = "small",
    srcs = [".hacking/scripts/verify_action_shas.sh"],
    data = glob([".github/workflows/*.yml"]),
    tags = ["requires-network"],
)

# Check that versions match across Cargo.toml, package.json, pyproject.toml
sh_test(
    name = "check_versions_match",
    size = "small",
    srcs = [".hacking/scripts/check_versions_match.sh"],
    data = [
        "Cargo.toml",
        "//editors/code:package.json",
        "//crates/cli-python:pyproject.toml",
        "pyproject.toml",
    ],
)

# Python ruff check - format and lint
sh_test(
    name = "ruff_check",
    size = "small",
    srcs = [".hacking/scripts/ruff_check.sh"],
    data = [
        "pyproject.toml",
        "//crates/cli-python:python_srcs",
        "@aspect_rules_lint//lint:ruff_bin",
    ] + glob([".hacking/**/*.py"]),
    env = {
        "RUFF": "$(rlocationpath @aspect_rules_lint//lint:ruff_bin)",
    },
)

# Python ruff fix - format and lint fix (for fixing locally and in CI)
sh_binary(
    name = "ruff_fix",
    srcs = [".hacking/scripts/ruff_fix.sh"],
    data = [
        "pyproject.toml",
        "//crates/cli-python:python_srcs",
        "@aspect_rules_lint//lint:ruff_bin",
    ] + glob([".hacking/**/*.py"]),
    env = {
        "RUFF": "$(rlocationpath @aspect_rules_lint//lint:ruff_bin)",
    },
)

# All Rust targets for linting
RUST_TARGETS = [
    "//crates/cli:sqruff",
    "//crates/cli-lib:sqruff-cli-lib",
    "//crates/lib:sqruff-lib",
    "//crates/lib-core:sqruff-lib-core",
    "//crates/lib-dialects:sqruff-lib-dialects",
    "//crates/lib-wasm:sqruff-wasm",
    "//crates/lineage:lineage",
    "//crates/lsp:sqruff-lsp",
    "//crates/sqlinference:sqruff-sqlinference",
]

# Common Cargo source files for cargo-based checks
# Used by cargo_machete, cargo_check, cargo_hack_check, rust_lint
filegroup(
    name = "cargo_srcs",
    srcs = [
        "Cargo.lock",
        "Cargo.toml",
        "rust-toolchain.toml",
        "//crates/cli:machete_srcs",
        "//crates/cli-lib:machete_srcs",
        "//crates/cli-python:machete_srcs",
        "//crates/lib:machete_srcs",
        "//crates/lib-core:machete_srcs",
        "//crates/lib-dialects:machete_srcs",
        "//crates/lib-wasm:machete_srcs",
        "//crates/lineage:machete_srcs",
        "//crates/lsp:machete_srcs",
        "//crates/sqlinference:machete_srcs",
    ],
)

# Vendor cargo dependencies and install Rust toolchain (cached until Cargo.lock changes)
# Installs Rust via rustup with clippy and rustfmt components
cargo_vendor(
    name = "cargo_vendor",
    manifests = [":cargo_srcs"],
    rust_version = "1.94.1",
    components = [
        "clippy",
        "rustfmt",
    ],
)

# Provider wrapper for vendored dependencies
cargo_vendor_provider(
    name = "cargo_deps",
    vendor = ":cargo_vendor",
)

# Pre-cache Python venv with all dev dependencies (cached until pyproject.toml changes)
# Uses the Bazel-managed Python 3.12 interpreter and uv for fast pip installs
python_venv(
    name = "python_venv",
    srcs = [
        "pyproject.toml",
    ],
    python = ["@python_3_12//:files"],
    uv = ["@uv//:uv"],
)

# Provider wrapper for Python venv
python_venv_provider(
    name = "python_deps",
    venv = ":python_venv",
)

# Rust format check
rustfmt_test(
    name = "rustfmt_check",
    targets = RUST_TARGETS,
)

# Rust clippy check
rust_clippy(
    name = "clippy_check",
    deps = RUST_TARGETS,
)

# Codegen docs check - verify generated docs are up to date
# Uses vendored Rust toolchain for hermetic builds (same as cargo_test)
cargo_test(
    name = "codegen_docs_check",
    srcs = [
        ":cargo_srcs",
        "docs/reference/cli.md",
        "docs/reference/rules.md",
        "docs/reference/templaters.md",
    ],
    vendor = ":cargo_deps",
    python_venv = ":python_deps",
    script = """
# Build the codegen binary
cargo build --bin sqruff -F codegen-docs --locked --offline

# Create temp directory for generated output
GENDIR=$(mktemp -d)
mkdir -p "$GENDIR/docs/reference"

# Run codegen from the gendir
(cd "$GENDIR" && GITHUB_ACTIONS=false "$CARGO_TARGET_DIR/debug/sqruff")

# Compare the generated files with the originals
FAILED=0

for doc in cli.md rules.md templaters.md; do
    if ! diff -q "docs/reference/$doc" "$GENDIR/docs/reference/$doc" > /dev/null 2>&1; then
        echo "ERROR: docs/reference/$doc is out of date"
        echo "Run 'cargo run --bin sqruff -F codegen-docs' to update"
        echo ""
        diff "docs/reference/$doc" "$GENDIR/docs/reference/$doc" || true
        FAILED=1
    fi
done

if [ $FAILED -eq 1 ]; then
    exit 1
fi

echo "All generated docs are up to date"
""",
)

# Codegen docs fix - regenerate docs and copy them back to the workspace
# Uses BUILD_WORKSPACE_DIRECTORY to write to the real workspace, mirroring
# how @rules_rust//:rustfmt operates.
cargo_run(
    name = "codegen_docs_fix",
    srcs = [
        ":cargo_srcs",
        "docs/reference/cli.md",
        "docs/reference/rules.md",
        "docs/reference/templaters.md",
    ],
    vendor = ":cargo_deps",
    python_venv = ":python_deps",
    script = """
# Build the codegen binary
cargo build --bin sqruff -F codegen-docs --locked --offline

# Run codegen into the real workspace
(cd "$BUILD_WORKSPACE_DIRECTORY" && GITHUB_ACTIONS=false "$CARGO_TARGET_DIR/debug/sqruff")

echo "Docs regenerated!"
""",
)

# Cargo machete - check for unused dependencies
# Note: Files are copied to a temp directory because cargo-machete doesn't follow symlinks
sh_test(
    name = "cargo_machete",
    size = "small",
    srcs = [".hacking/scripts/cargo_machete.sh"],
    data = [
        ":cargo_srcs",
        "@cargo_machete//:cargo-machete",
        "@rules_rust//rust/toolchain:current_cargo_files",
    ],
    env = {
        "CARGO": "$(rlocationpath @rules_rust//rust/toolchain:current_cargo_files)",
        "MACHETE": "$(rlocationpath @cargo_machete//:cargo-machete)",
        "RUSTUP_TOOLCHAIN": "stable",
    },
    tags = ["exclusive"],
)

# Cargo check - type-check all crates with all features, tests, and benches
# This replicates the "Rust Check" GitHub action job
# Uses vendored dependencies for hermetic builds
cargo_test(
    name = "cargo_check",
    srcs = [":cargo_srcs"],
    vendor = ":cargo_deps",
    script = "cargo check --all --all-features --tests --benches --locked --offline",
)

# Cargo build release - build release binaries with all features
# This replicates the "Compile" GitHub action job
# Uses vendored dependencies for hermetic builds
cargo_test(
    name = "cargo_build_release",
    size = "enormous",
    srcs = [":cargo_srcs"],
    vendor = ":cargo_deps",
    script = "cargo build --locked --release --all-features --offline",
)

# Cargo clippy - run clippy with all features
# Uses vendored dependencies for hermetic builds
cargo_test(
    name = "cargo_clippy",
    srcs = [":cargo_srcs"],
    vendor = ":cargo_deps",
    script = "cargo clippy --all --all-features --offline -- -D warnings",
)

# Cargo fmt check - verify code formatting
# Uses vendored dependencies for hermetic builds
cargo_test(
    name = "cargo_fmt_check",
    srcs = [":cargo_srcs"],
    vendor = ":cargo_deps",
    script = "cargo fmt --all -- --check",
)

# Cargo test - run all tests exactly like the GitHub Action
# Uses vendored Rust toolchain and pre-cached Python venv for fully sandboxed execution
# Python venv provides maturin, pytest, jinja2, dbt, etc.
cargo_test(
    name = "cargo_test",
    size = "enormous",
    srcs = [
        ":cargo_srcs",
        "pyproject.toml",
        "uv.lock",
        "//crates/cli:test_fixtures",
        "//crates/cli-python:machete_srcs",
        "//crates/cli-python:pyproject.toml",
        "//crates/cli-python:python_srcs",
        "//crates/cli-python:test_fixtures",
        "//crates/lib:test_fixtures",
        "//crates/lib-dialects:test_fixtures",
    ],
    vendor = ":cargo_deps",
    python_venv = ":python_deps",
    script = """
# Build Python extension (maturin uses the vendored cargo + pre-cached venv)
(cd crates/cli-python && maturin develop --locked --offline)

# Run cargo tests (same as GitHub Action)
cargo test --manifest-path ./crates/cli/Cargo.toml --locked --offline
# Crates that don't need the Python/maturin setup run natively via rust_test:
#   //crates/lib-core:sqruff-lib-core-test
#   //crates/sqlinference:sqruff-sqlinference-test
#   //crates/lineage:lineage-test
cargo test --all --all-features --exclude sqruff --exclude sqruff-lib-core --exclude sqruff-sqlinference --exclude lineage --locked --offline
""",
)

# Cargo hack check - verify each feature compiles in isolation
# This ensures no feature combination is broken
# Uses vendored dependencies for hermetic builds
cargo_test(
    name = "cargo_hack_check",
    size = "enormous",
    srcs = [":cargo_srcs"],
    tools = ["@cargo_hack//:cargo-hack"],
    vendor = ":cargo_deps",
    script = "cargo hack check --each-feature --exclude-features=codegen-docs --offline",
)

# Zensical docs build - verify documentation builds successfully
sh_test(
    name = "zensical_build",
    size = "large",
    srcs = [".hacking/scripts/zensical_build.sh"],
    data = [
        "pyproject.toml",
        "uv.lock",
        "zensical.toml",
        "@uv//:uv",
    ] + glob(["docs/**"]),
    env = {
        "UV": "$(rlocationpath @uv//:uv)",
    },
    tags = ["exclusive"],
)

# Zensical docs serve - build docs and optionally serve locally
# Usage: bazel run //:zensical_serve
#        bazel run //:zensical_serve -- --serve
sh_binary(
    name = "zensical_serve",
    srcs = [".hacking/scripts/zensical_serve.sh"],
)

# Zensical docs genrule tool - builds docs to output directory
sh_binary(
    name = "zensical_genrule_tool",
    srcs = [".hacking/scripts/zensical_genrule.sh"],
    data = [
        "pyproject.toml",
        "uv.lock",
        "zensical.toml",
        "@uv//:uv",
    ] + glob(["docs/**"]),
    env = {
        "UV": "$(rlocationpath @uv//:uv)",
    },
)

# Build zensical docs as output directory
run_binary(
    name = "docs_build",
    srcs = [
        "pyproject.toml",
        "uv.lock",
        "zensical.toml",
    ] + glob(["docs/**"]),
    outs = [],
    args = ["$(BINDIR)/docs_site"],
    out_dirs = ["docs_site"],
    tool = ":zensical_genrule_tool",
)

# Combined website: playground at root, docs at /docs
# Usage: bazel build //:website
copy_to_directory(
    name = "website",
    srcs = [
        "//playground:build",
        ":docs_build",
    ],
    out = "website",
    replace_prefixes = {
        "playground/dist": "",
        "docs_site": "docs",
    },
)

# Verify .sqlfluff-sha points to a real commit in sqlfluff/sqlfluff
sh_test(
    name = "verify_sqlfluff_sha",
    size = "small",
    srcs = [".hacking/scripts/verify_sqlfluff_sha.sh"],
    data = [".sqlfluff-sha"],
    tags = ["requires-network"],
)

# Python tests using uv - three incremental cached steps per version:
# 1. uv_python_install: download and cache the Python runtime (re-runs only when version changes)
# 2. uv_python_venv: sync dependencies into a cached venv (re-runs only when pyproject.toml/uv.lock change)
# 3. sh_test: run pytest using the cached venv (runs every time)
[
    uv_python_install(
        name = "pytest_py{}_python".format(version.replace(".", "")),
        python_version = version,
        uv = ["@uv//:uv"],
    )
    for version in [
        "3.10",
        "3.11",
        "3.12",
        "3.13",
    ]
]

[
    uv_python_venv(
        name = "pytest_py{}_venv".format(version.replace(".", "")),
        srcs = [
            "pyproject.toml",
            "uv.lock",
        ],
        python = [":pytest_py{}_python".format(version.replace(".", ""))],
        uv = ["@uv//:uv"],
    )
    for version in [
        "3.10",
        "3.11",
        "3.12",
        "3.13",
    ]
]

[
    sh_test(
        name = "pytest_py{}".format(version.replace(".", "")),
        size = "large",
        srcs = [".hacking/scripts/pytest_uv.sh"],
        data = [
            ":pytest_py{}_venv".format(version.replace(".", "")),
            "//crates/cli-python:python_srcs",
            "//crates/cli-python:test_fixtures",
        ],
        env = {
            "PYTHON_VENV": "$(rlocationpath :pytest_py{}_venv)".format(version.replace(".", "")),
        },
        tags = ["exclusive"],
    )
    for version in [
        "3.10",
        "3.11",
        "3.12",
        "3.13",
    ]
]