sqlbuild 0.38.2__tar.gz → 0.38.3__tar.gz

sqlbuild-0.38.3/.release-please-manifest.json

@@ -0,0 +1,3 @@
+{
+  ".": "0.38.3"
+}

{sqlbuild-0.38.2 → sqlbuild-0.38.3}/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## [0.38.3](https://github.com/chio-labs/sqlbuild/compare/v0.38.2...v0.38.3) (2026-06-24)
+
+
+### Bug Fixes
+
+* **dbt:** bound reuse git refresh ([bd40a8c](https://github.com/chio-labs/sqlbuild/commit/bd40a8c6abef5c08e6940391ba146ffc5543d490))
+* **dbt:** bound reuse git refresh ([0bbf200](https://github.com/chio-labs/sqlbuild/commit/0bbf2006c70f6248f05f43d2a62d3d3832838539))
+
 ## [0.38.2](https://github.com/chio-labs/sqlbuild/compare/v0.38.1...v0.38.2) (2026-06-23)
 
 

{sqlbuild-0.38.2 → sqlbuild-0.38.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlbuild
-Version: 0.38.2
+Version: 0.38.3
 Summary: Typed, test-first SQL pipelines with local E2E testing
 License-File: LICENSE
 Requires-Python: >=3.12

{sqlbuild-0.38.2 → sqlbuild-0.38.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "sqlbuild"
-version = "0.38.2"
+version = "0.38.3"
 description = "Typed, test-first SQL pipelines with local E2E testing"
 readme = "README.md"
 requires-python = ">=3.12"

{sqlbuild-0.38.2 → sqlbuild-0.38.3}/src/sqlbuild/compiler/discovery/helpers/yml/project.py

@@ -722,7 +722,9 @@ def _load_dbt_reuse_from(*, payload: object, file_path: Path) -> DbtReuseFromCon
     )
     _validate_allowed_keys(
         mapping=mapping,
-        allowed_keys=frozenset({"git_ref", "generate_schema_name_override"}),
+        allowed_keys=frozenset(
+            {"git_ref", "generate_schema_name_override", "refresh", "git_timeout_seconds"}
+        ),
         label="dbt.reuse_from",
         file_path=file_path,
     )
@@ -739,9 +741,18 @@ def _load_dbt_reuse_from(*, payload: object, file_path: Path) -> DbtReuseFromCon
         value=generate_schema_name_override,
         file_path=file_path,
     )
+    git_timeout_seconds: int = _optional_int(
+        mapping=mapping,
+        key="git_timeout_seconds",
+        default=30,
+    )
+    if git_timeout_seconds <= 0:
+        raise ProjectConfigError(f"{file_path} dbt.reuse_from.git_timeout_seconds must be > 0")
     return DbtReuseFromConfig(
         git_ref=git_ref,
         generate_schema_name_override=generate_schema_name_override,
+        refresh=_optional_bool(mapping=mapping, key="refresh", default=True),
+        git_timeout_seconds=git_timeout_seconds,
     )
 
 

{sqlbuild-0.38.2 → sqlbuild-0.38.3}/src/sqlbuild/integrations/dbt/helpers/cli/runner.py

@@ -30,6 +30,21 @@ def build_dbt_compile_argv(
     return argv
 
 
+def build_dbt_deps_argv(*, dbt_executable: str, options: DbtCliOptions) -> tuple[str, ...]:
+    """Build argv for dbt deps."""
+
+    argv: tuple[str, ...] = (dbt_executable, "deps")
+    if options.project_dir is not None:
+        argv = (*argv, "--project-dir", str(options.project_dir))
+    if options.profiles_dir is not None:
+        argv = (*argv, "--profiles-dir", str(options.profiles_dir))
+    if options.target is not None:
+        argv = (*argv, "--target", options.target)
+    if options.vars is not None:
+        argv = (*argv, "--vars", options.vars)
+    return argv
+
+
 def build_dbt_debug_argv(
     *, dbt_executable: str, options: DbtCliOptions, args: Sequence[str] = ()
 ) -> tuple[str, ...]:
@@ -123,6 +138,15 @@ class DbtRunner:
         )
         return self._invoke(argv=argv, cwd=options.project_dir)
 
+    def deps(self, *, options: DbtCliOptions) -> DbtCommandResult:
+        """Run dbt deps."""
+
+        argv: tuple[str, ...] = build_dbt_deps_argv(
+            dbt_executable=self.dbt_executable,
+            options=options,
+        )
+        return self._invoke(argv=argv, cwd=options.project_dir)
+
     def debug(self, *, options: DbtCliOptions, args: Sequence[str] = ()) -> DbtCommandResult:
         """Run dbt debug."""
 

{sqlbuild-0.38.2 → sqlbuild-0.38.3}/src/sqlbuild/integrations/dbt/helpers/reuse/reuse_from.py

@@ -60,14 +60,22 @@ def compile_reuse_from_manifest(
         archive_ref: str = _refresh_git_ref_for_archive(
             git_root=git_root,
             git_ref=reuse_from.git_ref,
+            refresh=reuse_from.refresh,
+            timeout_seconds=reuse_from.git_timeout_seconds,
         )
         _raise_if_missing_git_ref(
             git_root=git_root,
             git_ref=archive_ref,
             configured_ref=reuse_from.git_ref,
             project_file=sqlbuild_project_dir / "sqlbuild_project.toml",
+            timeout_seconds=reuse_from.git_timeout_seconds,
+        )
+        _extract_git_ref(
+            git_root=git_root,
+            git_ref=archive_ref,
+            destination=checkout_dir,
+            timeout_seconds=reuse_from.git_timeout_seconds,
         )
-        _extract_git_ref(git_root=git_root, git_ref=archive_ref, destination=checkout_dir)
 
         temp_dbt_project_dir: Path = checkout_dir / dbt_relative_dir
         _inject_generate_schema_name_override(
@@ -86,6 +94,13 @@ def compile_reuse_from_manifest(
             state=dbt_options.state,
             defer=dbt_options.defer,
         )
+        if _has_dbt_dependency_file(dbt_project_dir=temp_dbt_project_dir):
+            deps_command: DbtCommandResult = runner.deps(options=compile_options)
+            if deps_command.returncode != 0:
+                raise DbtInteropRuntimeError(
+                    "dbt reuse_from deps failed",
+                    help=deps_command.stderr or deps_command.stdout or None,
+                )
         command: DbtCommandResult = runner.compile(options=compile_options)
         if command.returncode != 0:
             raise DbtInteropRuntimeError(
@@ -118,6 +133,12 @@ def _git_root(*, path: Path) -> Path:
     return Path(result.stdout.strip()).resolve()
 
 
+def _has_dbt_dependency_file(*, dbt_project_dir: Path) -> bool:
+    return (dbt_project_dir / "packages.yml").is_file() or (
+        dbt_project_dir / "dependencies.yml"
+    ).is_file()
+
+
 def _relative_to_git_root(*, path: Path, git_root: Path, label: str) -> Path:
     resolved_path: Path = path.resolve()
     try:
@@ -148,7 +169,11 @@ def _raise_if_current_branch(*, git_root: Path, git_ref: str) -> None:
         )
 
 
-def _refresh_git_ref_for_archive(*, git_root: Path, git_ref: str) -> str:
+def _refresh_git_ref_for_archive(
+    *, git_root: Path, git_ref: str, refresh: bool, timeout_seconds: int
+) -> str:
+    if not refresh:
+        return git_ref
     tracking_ref: tuple[str, str, str] | None = _remote_tracking_ref(
         git_root=git_root,
         git_ref=git_ref,
@@ -158,7 +183,12 @@ def _refresh_git_ref_for_archive(*, git_root: Path, git_ref: str) -> str:
     remote, branch, remote_ref = tracking_ref
 
     result: subprocess.CompletedProcess[str] = _run_git_text(
-        "-C", str(git_root), "fetch", remote, branch
+        "-C",
+        str(git_root),
+        "fetch",
+        remote,
+        branch,
+        timeout_seconds=timeout_seconds,
     )
     if result.returncode != 0:
         raise DbtReuseUnavailableError(
@@ -170,10 +200,21 @@ def _refresh_git_ref_for_archive(*, git_root: Path, git_ref: str) -> str:
 
 
 def _raise_if_missing_git_ref(
-    *, git_root: Path, git_ref: str, configured_ref: str, project_file: Path
+    *,
+    git_root: Path,
+    git_ref: str,
+    configured_ref: str,
+    project_file: Path,
+    timeout_seconds: int,
 ) -> None:
     result: subprocess.CompletedProcess[str] = _run_git_text(
-        "-C", str(git_root), "rev-parse", "--verify", "--quiet", f"{git_ref}^{{commit}}"
+        "-C",
+        str(git_root),
+        "rev-parse",
+        "--verify",
+        "--quiet",
+        f"{git_ref}^{{commit}}",
+        timeout_seconds=timeout_seconds,
     )
     if result.returncode == 0:
         return
@@ -232,9 +273,11 @@ def _remote_tracking_ref(*, git_root: Path, git_ref: str) -> tuple[str, str, str
     return remote, branch, f"refs/remotes/{remote}/{branch}"
 
 
-def _extract_git_ref(*, git_root: Path, git_ref: str, destination: Path) -> None:
+def _extract_git_ref(
+    *, git_root: Path, git_ref: str, destination: Path, timeout_seconds: int
+) -> None:
     result: subprocess.CompletedProcess[bytes] = _run_git_bytes(
-        "-C", str(git_root), "archive", git_ref
+        "-C", str(git_root), "archive", git_ref, timeout_seconds=timeout_seconds
     )
     if result.returncode != 0:
         stderr: str = result.stderr.decode(errors="replace")
@@ -247,14 +290,24 @@ def _extract_git_ref(*, git_root: Path, git_ref: str, destination: Path) -> None
         archive.extractall(path=destination, filter="data")
 
 
-def _run_git_text(*args: str) -> subprocess.CompletedProcess[str]:
+def _run_git_text(*args: str, timeout_seconds: int = 30) -> subprocess.CompletedProcess[str]:
     try:
         return subprocess.run(
             ("git", *args),
             capture_output=True,
             check=False,
             text=True,
+            timeout=timeout_seconds,
         )
+    except subprocess.TimeoutExpired as error:
+        raise DbtReuseUnavailableError(
+            f"dbt reuse_from git command timed out after {timeout_seconds}s",
+            reason=DbtReuseUnavailableReason.REMOTE_REFRESH_FAILED,
+            help=(
+                "Check network/SSH access or set [dbt.reuse_from].refresh = false "
+                "to use the local ref."
+            ),
+        ) from error
     except FileNotFoundError as error:
         raise DbtInteropConfigError(
             "dbt reuse_from requires git to be installed and available on PATH",
@@ -262,13 +315,23 @@ def _run_git_text(*args: str) -> subprocess.CompletedProcess[str]:
         ) from error
 
 
-def _run_git_bytes(*args: str) -> subprocess.CompletedProcess[bytes]:
+def _run_git_bytes(*args: str, timeout_seconds: int = 30) -> subprocess.CompletedProcess[bytes]:
     try:
         return subprocess.run(
             ("git", *args),
             capture_output=True,
             check=False,
+            timeout=timeout_seconds,
         )
+    except subprocess.TimeoutExpired as error:
+        raise DbtReuseUnavailableError(
+            f"dbt reuse_from git command timed out after {timeout_seconds}s",
+            reason=DbtReuseUnavailableReason.REMOTE_REFRESH_FAILED,
+            help=(
+                "Check network/SSH access or set [dbt.reuse_from].refresh = false "
+                "to use the local ref."
+            ),
+        ) from error
     except FileNotFoundError as error:
         raise DbtInteropConfigError(
             "dbt reuse_from requires git to be installed and available on PATH",

{sqlbuild-0.38.2 → sqlbuild-0.38.3}/src/sqlbuild/integrations/dbt/pipeline/main/plan.py

@@ -177,6 +177,10 @@ def plan_dbt_interop_from_project(
         dbt_executable=dbt_executable,
         sqlbuild_executable=sqlbuild_executable,
     )
+    _report_progress(
+        on_progress,
+        f"Resolved dbt and SQLBuild selection. ({time.monotonic() - selection_start:.2f}s)",
+    )
     dbt_model_plan: DbtModelPlanningResult | None = build_dbt_model_plan_output(
         project_dir=project_dir,
         discovered_inputs=discovered_inputs,

{sqlbuild-0.38.2 → sqlbuild-0.38.3}/src/sqlbuild/spec/models/project.py

@@ -162,6 +162,8 @@ class DbtReuseFromConfig:
 
     git_ref: str | None = None
     generate_schema_name_override: str | None = None
+    refresh: bool = True
+    git_timeout_seconds: int = 30
 
 
 @dataclass(frozen=True)

{sqlbuild-0.38.2 → sqlbuild-0.38.3}/tests/unit/src/sqlbuild/compiler/discovery/helpers/_test_types.py

@@ -53,6 +53,8 @@ class LoadProjectConfigTestCase:
     expected_dbt_vars: dict[str, object] = field(default_factory=dict)
     expected_dbt_reuse_from_git_ref: str | None = None
     expected_dbt_reuse_from_generate_schema_name_override: str | None = None
+    expected_dbt_reuse_from_refresh: bool = True
+    expected_dbt_reuse_from_git_timeout_seconds: int = 30
     expected_auto_load_sources: bool = True
     expected_virtual_environments: bool = False
     expected_force: bool = False

{sqlbuild-0.38.2 → sqlbuild-0.38.3}/tests/unit/src/sqlbuild/compiler/discovery/helpers/test_yml_project.py

@@ -318,6 +318,8 @@ adapter = "duckdb"
 [dbt.reuse_from]
 git_ref = "prod"
 generate_schema_name_override = "dbt/macros/prod_generate_schema_name.sql"
+refresh = false
+git_timeout_seconds = 12
 """.strip(),
         expected_error_fragment="generate_schema_name_override file not found",
     ),
@@ -844,6 +846,8 @@ enabled = true
 [dbt.reuse_from]
 git_ref = "prod"
 generate_schema_name_override = "dbt/macros/prod_generate_schema_name.sql"
+refresh = false
+git_timeout_seconds = 12
 """.strip(),
         expected_name="demo",
         expected_adapter="duckdb",
@@ -913,6 +917,8 @@ generate_schema_name_override = "dbt/macros/prod_generate_schema_name.sql"
         expected_dbt_reuse_from_generate_schema_name_override=(
             "dbt/macros/prod_generate_schema_name.sql"
         ),
+        expected_dbt_reuse_from_refresh=False,
+        expected_dbt_reuse_from_git_timeout_seconds=12,
     ),
 ]
 
@@ -995,6 +1001,11 @@ def test_given_project_config_file_when_loading_project_config_then_it_returns_e
         config.dbt.reuse_from.generate_schema_name_override
         == test_case.expected_dbt_reuse_from_generate_schema_name_override
     )
+    assert config.dbt.reuse_from.refresh is test_case.expected_dbt_reuse_from_refresh
+    assert (
+        config.dbt.reuse_from.git_timeout_seconds
+        == test_case.expected_dbt_reuse_from_git_timeout_seconds
+    )
 
 
 @pytest.mark.parametrize(

{sqlbuild-0.38.2 → sqlbuild-0.38.3}/tests/unit/src/sqlbuild/integrations/dbt/_test_types.py

@@ -89,6 +89,29 @@ class DbtRunnerCommandTestCase:
     expected_argv: tuple[str, ...]
 
 
+@dataclass(frozen=True)
+class DbtReuseGitTimeoutTestCase:
+    description: str
+    timeout_seconds: int
+    expected_error_fragment: str
+
+
+@dataclass(frozen=True)
+class DbtReuseGitRefreshTestCase:
+    description: str
+    git_ref: str
+    refresh: bool
+    expected_archive_ref: str
+    expected_run_calls: int
+
+
+@dataclass(frozen=True)
+class DbtReuseCompileDepsTestCase:
+    description: str
+    expected_commands: tuple[str, ...]
+    expected_manifest_contents: str
+
+
 @dataclass(frozen=True)
 class DbtModeGuardTestCase:
     description: str

sqlbuild-0.38.3/tests/unit/src/sqlbuild/integrations/dbt/test_reuse_from.py

@@ -0,0 +1,151 @@
+from __future__ import annotations
+
+import subprocess
+from pathlib import Path
+
+import pytest
+
+from sqlbuild.integrations.dbt.exceptions import DbtReuseUnavailableError
+from sqlbuild.integrations.dbt.helpers.cli.runner import DbtRunner
+from sqlbuild.integrations.dbt.helpers.reuse import reuse_from as reuse_from_module
+from sqlbuild.integrations.dbt.models import (
+    DbtCliOptions,
+    DbtCommandResult,
+    DbtReuseFromCompileResult,
+)
+from sqlbuild.spec.models.project import DbtReuseFromConfig
+from tests.unit.src.sqlbuild.integrations.dbt._test_types import (
+    DbtReuseCompileDepsTestCase,
+    DbtReuseGitRefreshTestCase,
+    DbtReuseGitTimeoutTestCase,
+)
+
+
+@pytest.mark.parametrize(
+    "test_case",
+    [
+        DbtReuseGitTimeoutTestCase(
+            description="raises reuse unavailable when git command times out",
+            timeout_seconds=7,
+            expected_error_fragment="timed out after 7s",
+        )
+    ],
+    ids=["raises reuse unavailable when git command times out"],
+)
+def test_given_git_command_timeout_when_running_git_text_then_raises_reuse_unavailable(
+    test_case: DbtReuseGitTimeoutTestCase,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    def run(*args: object, **kwargs: object) -> subprocess.CompletedProcess[str]:
+        raise subprocess.TimeoutExpired(cmd=("git", "fetch"), timeout=test_case.timeout_seconds)
+
+    monkeypatch.setattr(reuse_from_module.subprocess, "run", run)
+
+    with pytest.raises(DbtReuseUnavailableError, match=test_case.expected_error_fragment):
+        reuse_from_module._run_git_text("fetch", timeout_seconds=test_case.timeout_seconds)
+
+
+@pytest.mark.parametrize(
+    "test_case",
+    [
+        DbtReuseGitRefreshTestCase(
+            description="refresh false archives configured local ref without fetching",
+            git_ref="master",
+            refresh=False,
+            expected_archive_ref="master",
+            expected_run_calls=0,
+        )
+    ],
+    ids=["refresh false archives configured local ref without fetching"],
+)
+def test_given_refresh_disabled_when_refreshing_git_ref_then_skips_fetch(
+    test_case: DbtReuseGitRefreshTestCase,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    run_calls: list[tuple[object, ...]] = []
+
+    def run(*args: object, **kwargs: object) -> subprocess.CompletedProcess[str]:
+        run_calls.append(args)
+        return subprocess.CompletedProcess(args=("git",), returncode=0, stdout="", stderr="")
+
+    monkeypatch.setattr(reuse_from_module.subprocess, "run", run)
+
+    archive_ref: str = reuse_from_module._refresh_git_ref_for_archive(
+        git_root=Path("/repo"),
+        git_ref=test_case.git_ref,
+        refresh=test_case.refresh,
+        timeout_seconds=30,
+    )
+
+    assert archive_ref == test_case.expected_archive_ref
+    assert len(run_calls) == test_case.expected_run_calls
+
+
+@pytest.mark.parametrize(
+    "test_case",
+    [
+        DbtReuseCompileDepsTestCase(
+            description="runs dbt deps before compile when archived project declares packages",
+            expected_commands=("deps", "compile"),
+            expected_manifest_contents='{"metadata": {}}',
+        )
+    ],
+    ids=["runs dbt deps before compile when archived project declares packages"],
+)
+def test_given_reuse_checkout_with_packages_when_compiling_then_runs_deps_before_compile(
+    test_case: DbtReuseCompileDepsTestCase,
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    sqlbuild_project_dir: Path = tmp_path / "sqlbuild_project"
+    macro_source: Path = sqlbuild_project_dir / "dbt" / "macros" / "generate_schema_name.sql"
+    macro_source.parent.mkdir(parents=True)
+    macro_source.write_text(
+        "{% macro generate_schema_name(custom_schema_name, node) %}{% endmacro %}", encoding="utf-8"
+    )
+    dbt_project_dir: Path = tmp_path / "repo" / "dbt_project"
+    dbt_project_dir.mkdir(parents=True)
+    command_names: list[str] = []
+
+    def extract_git_ref(
+        *, git_root: Path, git_ref: str, destination: Path, timeout_seconds: int
+    ) -> None:
+        del git_root, git_ref, timeout_seconds
+        temp_project_dir: Path = destination / "dbt_project"
+        temp_project_dir.mkdir()
+        (temp_project_dir / "packages.yml").write_text("packages: []\n", encoding="utf-8")
+        target_path: Path = destination.parent / "target"
+        target_path.mkdir()
+        (target_path / "manifest.json").write_text(
+            test_case.expected_manifest_contents,
+            encoding="utf-8",
+        )
+
+    def invoke(argv: tuple[str, ...], cwd: Path | None) -> DbtCommandResult:
+        del cwd
+        command_names.append(argv[1])
+        return DbtCommandResult(argv=argv, returncode=0)
+
+    monkeypatch.setattr(reuse_from_module, "_git_root", lambda *, path: tmp_path / "repo")
+    monkeypatch.setattr(reuse_from_module, "_raise_if_current_branch", lambda **kwargs: None)
+    monkeypatch.setattr(
+        reuse_from_module, "_relative_to_git_root", lambda **kwargs: Path("dbt_project")
+    )
+    monkeypatch.setattr(
+        reuse_from_module, "_refresh_git_ref_for_archive", lambda **kwargs: "master"
+    )
+    monkeypatch.setattr(reuse_from_module, "_raise_if_missing_git_ref", lambda **kwargs: None)
+    monkeypatch.setattr(reuse_from_module, "_extract_git_ref", extract_git_ref)
+
+    result: DbtReuseFromCompileResult = reuse_from_module.compile_reuse_from_manifest(
+        sqlbuild_project_dir=sqlbuild_project_dir,
+        dbt_options=DbtCliOptions(project_dir=dbt_project_dir),
+        reuse_from=DbtReuseFromConfig(
+            git_ref="master",
+            generate_schema_name_override="dbt/macros/generate_schema_name.sql",
+        ),
+        runner=DbtRunner(dbt_executable="dbt", invoker=invoke),
+    )
+
+    assert tuple(command_names) == test_case.expected_commands
+    assert result.manifest_contents == test_case.expected_manifest_contents

{sqlbuild-0.38.2 → sqlbuild-0.38.3}/tests/unit/src/sqlbuild/integrations/dbt/test_runner.py

@@ -8,6 +8,7 @@ from sqlbuild.integrations.dbt.helpers.cli.runner import (
     DbtRunner,
     build_dbt_compile_argv,
     build_dbt_debug_argv,
+    build_dbt_deps_argv,
     build_dbt_ls_argv,
     parse_dbt_ls_json_lines,
 )
@@ -119,6 +120,40 @@ def test_given_dbt_options_when_building_compile_argv_then_returns_expected_comm
     assert result == test_case.expected_argv
 
 
+@pytest.mark.parametrize(
+    "test_case",
+    [
+        DbtArgvTestCase(
+            description="builds deps argv with project profile target and vars only",
+            select=(),
+            exclude=(),
+            resource_types=(),
+            expected_argv=(
+                "dbt",
+                "deps",
+                "--project-dir",
+                "/repo/dbt",
+                "--profiles-dir",
+                "/repo/profiles",
+                "--target",
+                "prod",
+                "--vars",
+                '{"run_date":"2026-01-01"}',
+            ),
+        )
+    ],
+    ids=["builds deps argv with project profile target and vars only"],
+)
+def test_given_dbt_options_when_building_deps_argv_then_returns_expected_command(
+    test_case: DbtArgvTestCase,
+) -> None:
+    options: DbtCliOptions = build_dbt_cli_options(PROJECT_ROOT)
+
+    result: tuple[str, ...] = build_dbt_deps_argv(dbt_executable="dbt", options=options)
+
+    assert result == test_case.expected_argv
+
+
 @pytest.mark.parametrize(
     "test_case",
     [

sqlbuild-0.38.2/.release-please-manifest.json

@@ -1,3 +0,0 @@
-{
-  ".": "0.38.2"
-}