sqlbuild 0.55.5__tar.gz → 0.55.7__tar.gz

{sqlbuild-0.55.5 → sqlbuild-0.55.7}/Cargo.lock

@@ -572,7 +572,7 @@ checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba"
 
 [[package]]
 name = "sqlbuild-kata-native"
-version = "0.55.5"
+version = "0.55.7"
 dependencies = [
  "fensu-policy",
  "globset",

{sqlbuild-0.55.5 → sqlbuild-0.55.7}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: sqlbuild
-Version: 0.55.5
+Version: 0.55.7
 Requires-Dist: duckdb>=1.3.2
-Requires-Dist: polyglot-sql>=0.5.10
+Requires-Dist: polyglot-sql>=0.9.2
 Requires-Dist: pydantic-settings>=2,<3
 Requires-Dist: pyyaml>=6.0.2
 Requires-Dist: rich>=15.0.0

{sqlbuild-0.55.5 → sqlbuild-0.55.7}/crates/sqlbuild-kata-native/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sqlbuild-kata-native"
-version = "0.55.5"
+version = "0.55.7"
 edition.workspace = true
 license.workspace = true
 publish.workspace = true

{sqlbuild-0.55.5 → sqlbuild-0.55.7}/pyproject.toml

@@ -7,13 +7,13 @@ build-backend = "maturin"
 
 [project]
 name = "sqlbuild"
-version = "0.55.5"
+version = "0.55.7"
 description = "Typed, test-first SQL pipelines with local E2E testing"
 readme = "README.md"
 requires-python = ">=3.12"
 dependencies = [
   "duckdb>=1.3.2",
-  "polyglot-sql>=0.5.10",
+  "polyglot-sql>=0.9.2",
   "pydantic-settings>=2,<3",
   "PyYAML>=6.0.2",
   "rich>=15.0.0",

{sqlbuild-0.55.5 → sqlbuild-0.55.7}/src/sqlbuild/compiler/compile/_helpers/analysis/cache.py

@@ -3,12 +3,14 @@
 from __future__ import annotations
 
 import hashlib
+import hmac
 import inspect
 import json
 import platform
 import sqlite3
 from importlib.metadata import PackageNotFoundError, version
 from pathlib import Path
+from string import hexdigits
 from typing import Any, cast
 
 from sqlbuild.adapter.contract.models import ExpressionInferenceProfile
@@ -29,9 +31,11 @@ from sqlbuild.compiler.lineage.types import (
 )
 from sqlbuild.compiler.references.types import SqlReferenceKind
 
-_ANALYSIS_CACHE_VERSION: int = 2
-_ANALYSIS_ALGORITHM_FINGERPRINT: str = "model-sql-analysis-v2"
+_ANALYSIS_CACHE_VERSION: int = 4
+_ANALYSIS_ALGORITHM_FINGERPRINT: str = "model-sql-analysis-v4"
 _MAX_CACHE_ENTRY_BYTES: int = 10_000_000
+_SHA256_HEX_LENGTH: int = 64
+_CACHE_ENTRY_SEPARATOR: str = "\n"
 _LOCAL_QUALNAME_MARKER: str = "<locals>"
 _SQLITE_QUERY_CHUNK_SIZE: int = 500
 _SQLITE_TIMEOUT_SECONDS: float = 0.1
@@ -138,14 +142,15 @@ def read_model_analyses(
     cache_keys: tuple[str, ...],
     model_names: tuple[str, ...],
     upstream_model_names_by_key: dict[str, tuple[str, ...]],
-) -> tuple[dict[str, PolyglotAnalysisResult], dict[str, str]]:
+) -> tuple[dict[str, PolyglotAnalysisResult], dict[str, str], dict[str, str]]:
     """Read one consistent snapshot of analyses, dependencies, and output signatures."""
 
     database_path: Path = _cache_database_path(context=context)
     if not database_path.is_file() or not cache_keys:
-        return {}, {}
+        return {}, {}, {}
     analyses: dict[str, PolyglotAnalysisResult] = {}
     signatures: dict[str, str] = {}
+    output_signatures_by_key: dict[str, str] = {}
     try:
         connection_uri: str = f"file:{database_path}?mode=ro"
         with sqlite3.connect(
@@ -202,15 +207,19 @@ def read_model_analyses(
                         or dependencies_by_key.get(cache_key, {}) != expected_dependencies
                     ):
                         continue
-                    analysis: PolyglotAnalysisResult | None = _analysis_from_contents(
-                        contents=contents,
-                        expected_cache_key=cache_key,
+                    cached_result: tuple[PolyglotAnalysisResult, str] | None = (
+                        _analysis_from_contents(
+                            contents=contents,
+                            expected_cache_key=cache_key,
+                        )
                     )
-                    if analysis is not None:
+                    if cached_result is not None:
+                        analysis, output_signature = cached_result
                         analyses[cache_key] = analysis
+                        output_signatures_by_key[cache_key] = output_signature
     except (OSError, sqlite3.DatabaseError):
-        return {}, {}
-    return analyses, signatures
+        return {}, {}, {}
+    return analyses, signatures, output_signatures_by_key
 
 
 def write_model_analyses(
@@ -222,19 +231,13 @@ def write_model_analyses(
 ) -> None:
     """Transactionally persist successful analyses; cache failures never fail compilation."""
 
-    rows: list[tuple[str, str]] = [
-        (
-            cache_key,
-            json.dumps(
-                _analysis_payload(cache_key=cache_key, analysis=analysis),
-                ensure_ascii=False,
-                separators=(",", ":"),
-                sort_keys=True,
-            ),
-        )
-        for cache_key, analysis in analyses_by_key.items()
-        if analysis.analysis_succeeded
-    ]
+    rows: list[tuple[str, str]] = []
+    for cache_key, analysis in analyses_by_key.items():
+        if not analysis.analysis_succeeded:
+            continue
+        contents: str = _analysis_contents(cache_key=cache_key, analysis=analysis)
+        if len(contents.encode()) <= _MAX_CACHE_ENTRY_BYTES:
+            rows.append((cache_key, contents))
     signature_rows: list[tuple[str, str, str, str]] = [
         (
             context.shared_fingerprint,
@@ -327,14 +330,25 @@ def model_analysis_output_signature(analysis: PolyglotAnalysisResult) -> str:
 
 
 def _analysis_from_contents(
-    *, contents: str, expected_cache_key: str
-) -> PolyglotAnalysisResult | None:
-    if len(contents.encode("utf-8")) > _MAX_CACHE_ENTRY_BYTES:
+    *, contents: object, expected_cache_key: str
+) -> tuple[PolyglotAnalysisResult, str] | None:
+    if not isinstance(contents, str):
         return None
     try:
-        payload: object = json.loads(contents)
+        if len(contents.encode()) > _MAX_CACHE_ENTRY_BYTES:
+            return None
+        stored_digest, separator, serialized_payload = contents.partition(_CACHE_ENTRY_SEPARATOR)
+        if not separator or not hmac.compare_digest(
+            stored_digest,
+            _cache_entry_digest(
+                cache_key=expected_cache_key,
+                serialized_payload=serialized_payload,
+            ),
+        ):
+            return None
+        payload: object = json.loads(serialized_payload)
         return _analysis_from_payload(payload=payload, expected_cache_key=expected_cache_key)
-    except (ValueError, TypeError, KeyError, json.JSONDecodeError):
+    except (ValueError, TypeError, KeyError, RecursionError, json.JSONDecodeError):
         return None
 
 
@@ -418,118 +432,154 @@ def _referenced_analysis_tables(
 
 
 def _analysis_payload(*, cache_key: str, analysis: PolyglotAnalysisResult) -> dict[str, object]:
-    analysis_payload: dict[str, object] = {
-        "columns": (
+    return {
+        "v": _ANALYSIS_CACHE_VERSION,
+        "k": cache_key,
+        "s": model_analysis_output_signature(analysis),
+        "c": (
             None
             if analysis.columns is None
             else [
-                {
-                    "name": column.name,
-                    "type": column.type,
-                    "nullability": column.nullability.value,
-                }
-                for column in analysis.columns
+                [column.name, column.type, column.nullability.value] for column in analysis.columns
             ]
         ),
-        "lineage_columns": [_lineage_column_payload(column) for column in analysis.lineage_columns],
-        "has_star": analysis.has_star,
-    }
-    return {
-        "version": _ANALYSIS_CACHE_VERSION,
-        "cache_key": cache_key,
-        "analysis_succeeded": True,
-        "analysis_digest": _payload_digest(analysis_payload),
-        "analysis": analysis_payload,
+        "l": [_lineage_column_payload(column) for column in analysis.lineage_columns],
+        "h": analysis.has_star,
     }
 
 
-def _lineage_column_payload(column: CompiledLineageColumnFact) -> dict[str, object]:
-    return {
-        "output_column": column.output_column,
-        "transform_kind": column.transform_kind.value,
-        "confidence": column.confidence.value,
-        "upstream_columns": [
-            {
-                "resource_type": str(source.resource_type),
-                "resource_name": source.resource_name,
-                "column_name": source.column_name,
-            }
+def _lineage_column_payload(column: CompiledLineageColumnFact) -> list[object]:
+    return [
+        column.output_column,
+        column.transform_kind.value,
+        column.confidence.value,
+        [
+            [
+                str(source.resource_type),
+                source.resource_name,
+                source.column_name,
+            ]
             for source in column.upstream_columns
         ],
-    }
+    ]
 
 
-def _analysis_from_payload(*, payload: object, expected_cache_key: str) -> PolyglotAnalysisResult:
+def _analysis_from_payload(
+    *, payload: object, expected_cache_key: str
+) -> tuple[PolyglotAnalysisResult, str]:
     if not isinstance(payload, dict):
         raise AnalysisCacheEntryError("analysis cache entry must be an object")
     values: dict[str, Any] = cast(dict[str, Any], payload)
-    version_value: object = values["version"]
+    version_value: object = values["v"]
     if type(version_value) is not int or version_value != _ANALYSIS_CACHE_VERSION:
         raise AnalysisCacheEntryError("analysis cache version mismatch")
-    if values["cache_key"] != expected_cache_key:
+    if values["k"] != expected_cache_key:
         raise AnalysisCacheEntryError("analysis cache key mismatch")
-    if values["analysis_succeeded"] is not True:
-        raise AnalysisCacheEntryError("analysis cache contains an unsuccessful result")
-    analysis_payload: object = values["analysis"]
-    if not isinstance(analysis_payload, dict):
-        raise AnalysisCacheEntryError("analysis cache facts must be an object")
-    if values["analysis_digest"] != _payload_digest(analysis_payload):
-        raise AnalysisCacheEntryError("analysis cache facts checksum mismatch")
-    analysis_values: dict[str, Any] = cast(dict[str, Any], analysis_payload)
-    columns_payload: object = analysis_values["columns"]
+    output_signature: object = values["s"]
+    if not (
+        isinstance(output_signature, str)
+        and len(output_signature) == _SHA256_HEX_LENGTH
+        and all(character in hexdigits for character in output_signature)
+    ):
+        raise AnalysisCacheEntryError("analysis cache output signature is invalid")
+    columns_payload: object = values["c"]
     columns: tuple[InferredColumn, ...] | None = (
         None
         if columns_payload is None
-        else tuple(
-            InferredColumn(
-                name=str(column["name"]),
-                type=None if column.get("type") is None else str(column["type"]),
-                nullability=InferredNullability(str(column["nullability"])),
-            )
-            for column in _object_list(columns_payload)
-        )
+        else tuple(_column_from_payload(column) for column in _value_lists(columns_payload))
     )
     lineage_columns: tuple[CompiledLineageColumnFact, ...] = tuple(
-        _lineage_column_from_payload(column)
-        for column in _object_list(analysis_values["lineage_columns"])
+        _lineage_column_from_payload(column) for column in _value_lists(values["l"])
     )
-    has_star: object = analysis_values["has_star"]
+    has_star: object = values["h"]
     if not isinstance(has_star, bool):
         raise AnalysisCacheEntryError("analysis cache has_star must be a boolean")
-    return PolyglotAnalysisResult(
-        analysis_succeeded=True,
-        columns=columns,
-        lineage_columns=lineage_columns,
-        has_star=has_star,
+    return (
+        PolyglotAnalysisResult(
+            analysis_succeeded=True,
+            columns=columns,
+            lineage_columns=lineage_columns,
+            has_star=has_star,
+        ),
+        output_signature,
     )
 
 
-def _object_list(payload: object) -> list[dict[str, Any]]:
-    if not isinstance(payload, list) or not all(isinstance(item, dict) for item in payload):
-        raise AnalysisCacheEntryError("analysis cache collection must contain objects")
-    return cast(list[dict[str, Any]], payload)
+def _value_lists(payload: object) -> list[list[object]]:
+    if not isinstance(payload, list) or not all(isinstance(item, list) for item in payload):
+        raise AnalysisCacheEntryError("analysis cache collection must contain arrays")
+    return cast(list[list[object]], payload)
+
+
+def _column_from_payload(payload: list[object]) -> InferredColumn:
+    column_value_count: int = 3
+    if len(payload) != column_value_count:
+        raise AnalysisCacheEntryError("analysis cache column must contain three values")
+    name, column_type, nullability = payload
+    if not isinstance(name, str) or not isinstance(nullability, str):
+        raise AnalysisCacheEntryError("analysis cache column name and nullability must be strings")
+    if column_type is not None and not isinstance(column_type, str):
+        raise AnalysisCacheEntryError("analysis cache column type must be a string or null")
+    return InferredColumn(
+        name=name,
+        type=column_type,
+        nullability=InferredNullability(nullability),
+    )
 
 
-def _lineage_column_from_payload(payload: dict[str, Any]) -> CompiledLineageColumnFact:
+def _lineage_column_from_payload(payload: list[object]) -> CompiledLineageColumnFact:
+    lineage_value_count: int = 4
+    if len(payload) != lineage_value_count:
+        raise AnalysisCacheEntryError("analysis cache lineage column must contain four values")
+    output_column, transform_kind, confidence, upstream_columns = payload
+    if not all(isinstance(value, str) for value in (output_column, transform_kind, confidence)):
+        raise AnalysisCacheEntryError("analysis cache lineage attributes must be strings")
     return CompiledLineageColumnFact(
-        output_column=str(payload["output_column"]),
-        transform_kind=ColumnTransformKind(str(payload["transform_kind"])),
-        confidence=ColumnLineageConfidence(str(payload["confidence"])),
+        output_column=cast(str, output_column),
+        transform_kind=ColumnTransformKind(cast(str, transform_kind)),
+        confidence=ColumnLineageConfidence(cast(str, confidence)),
         upstream_columns=tuple(
-            CompiledLineageSourceFact(
-                resource_type=str(source["resource_type"]),
-                resource_name=str(source["resource_name"]),
-                column_name=str(source["column_name"]),
-            )
-            for source in _object_list(payload["upstream_columns"])
+            _lineage_source_from_payload(source) for source in _value_lists(upstream_columns)
         ),
     )
 
 
+def _lineage_source_from_payload(payload: list[object]) -> CompiledLineageSourceFact:
+    source_value_count: int = 3
+    if len(payload) != source_value_count or not all(isinstance(value, str) for value in payload):
+        raise AnalysisCacheEntryError("analysis cache lineage source must contain three strings")
+    resource_type, resource_name, column_name = cast(list[str], payload)
+    return CompiledLineageSourceFact(
+        resource_type=resource_type,
+        resource_name=resource_name,
+        column_name=column_name,
+    )
+
+
 def _cache_database_path(*, context: AnalysisCacheContext) -> Path:
     return context.root / f"v{_ANALYSIS_CACHE_VERSION}" / _CACHE_DATABASE_NAME
 
 
+def _analysis_contents(*, cache_key: str, analysis: PolyglotAnalysisResult) -> str:
+    serialized_payload: str = json.dumps(
+        _analysis_payload(cache_key=cache_key, analysis=analysis),
+        ensure_ascii=False,
+        separators=(",", ":"),
+        sort_keys=True,
+    )
+    return _CACHE_ENTRY_SEPARATOR.join(
+        (
+            _cache_entry_digest(cache_key=cache_key, serialized_payload=serialized_payload),
+            serialized_payload,
+        )
+    )
+
+
+def _cache_entry_digest(*, cache_key: str, serialized_payload: str) -> str:
+    encoded: bytes = f"{cache_key}\0{serialized_payload}".encode()
+    return hashlib.sha256(encoded).hexdigest()
+
+
 def _payload_digest(payload: object) -> str:
     encoded: bytes = json.dumps(
         payload,

{sqlbuild-0.55.5 → sqlbuild-0.55.7}/src/sqlbuild/compiler/compile/_helpers/analysis/tests.py

@@ -20,6 +20,9 @@ from sqlbuild.compiler.compile.constants import (
 from sqlbuild.compiler.compile.exceptions import CompileInputError
 from sqlbuild.compiler.sql_analysis.main.import_polyglot_sql import import_polyglot_sql
 
+_POLYGLOT_VALUES_EXPRESSION_NAME: str = "Values"
+_POLYGLOT_VALUES_SET_ALIAS: str = "_values"
+
 
 def extract_expected_branch_column_names_with_sql_analysis(
     *, sql: str, file_label: str
@@ -56,6 +59,11 @@ def _extract_branch_names(*, expression: Any, file_label: str) -> tuple[tuple[st
             *_extract_branch_names(expression=right_expression, file_label=file_label),
         )
     if expression.__class__.__name__ == POLYGLOT_SELECT_EXPRESSION_NAME:
+        if _is_synthetic_values_set_branch(expression):
+            raise CompileInputError(
+                f"SQL test '{file_label}' must define each __expected__<model> set-operation "
+                "branch as a SELECT query"
+            )
         return (_extract_select_names(expression=expression, file_label=file_label),)
     raise CompileInputError(
         f"SQL test '{file_label}' must define each __expected__<model> set-operation "
@@ -63,6 +71,19 @@ def _extract_branch_names(*, expression: Any, file_label: str) -> tuple[tuple[st
     )
 
 
+def _is_synthetic_values_set_branch(expression: Any) -> bool:
+    """Recognize Polyglot's SELECT wrapper around a VALUES set operand."""
+
+    projections: tuple[Any, ...] = tuple(expression.expressions)
+    if len(projections) != 1 or not projections[0].is_star:
+        return False
+    values_expression: Any | None = expression.find(_POLYGLOT_VALUES_EXPRESSION_NAME)
+    if values_expression is None:
+        return False
+    alias: object = values_expression.args.get("alias")
+    return isinstance(alias, dict) and alias.get("name") == _POLYGLOT_VALUES_SET_ALIAS
+
+
 def _unwrap_expression(*, expression: Any) -> Any:
     while expression.__class__.__name__ in POLYGLOT_WRAPPER_EXPRESSION_NAMES:
         expression = expression.this

{sqlbuild-0.55.5 → sqlbuild-0.55.7}/src/sqlbuild/compiler/compile/_helpers/assembly/project.py

@@ -385,7 +385,8 @@ def _analyze_model_sql_in_parallel(
     )
     cached_analyses: dict[str, PolyglotAnalysisResult]
     previous_signatures: dict[str, str]
-    cached_analyses, previous_signatures = (
+    cached_output_signatures_by_key: dict[str, str]
+    cached_analyses, previous_signatures, cached_output_signatures_by_key = (
         read_model_analyses(
             context=analysis_cache,
             cache_keys=tuple(
@@ -399,7 +400,7 @@ def _analyze_model_sql_in_parallel(
             },
         )
         if analysis_cache is not None
-        else ({}, {})
+        else ({}, {}, {})
     )
     analyses: tuple[_ModelSqlAnalysis, ...] = _analyze_model_sql_requests(
         requests=requests,
@@ -414,8 +415,12 @@ def _analyze_model_sql_in_parallel(
         for request, analysis in zip(requests, analyses, strict=True)
     }
     current_signatures_by_name: dict[str, str] = {
-        model_name: model_analysis_output_signature(analysis)
-        for model_name, analysis in current_analyses_by_name.items()
+        _model_name(request.model_input): (
+            cached_output_signatures_by_key[request.cache_key]
+            if request.cache_key is not None and request.cache_key in cached_analyses
+            else model_analysis_output_signature(analysis.polyglot_analysis)
+        )
+        for request, analysis in zip(requests, analyses, strict=True)
     }
     analyses_to_record_by_name: dict[str, PolyglotAnalysisResult] = {
         _model_name(request.model_input): analysis.polyglot_analysis
@@ -475,10 +480,12 @@ def _analyze_model_sql_in_parallel(
             _model_name(request.model_input): analysis.polyglot_analysis
             for request, analysis in zip(requests, analyses, strict=True)
         }
-        current_signatures_by_name = {
-            model_name: model_analysis_output_signature(analysis)
-            for model_name, analysis in current_analyses_by_name.items()
-        }
+        current_signatures_by_name.update(
+            {
+                model_name: model_analysis_output_signature(invalidated_analysis.polyglot_analysis)
+                for model_name, invalidated_analysis in invalidated_analyses_by_name.items()
+            }
+        )
     if analysis_cache is not None:
         write_model_analyses(
             context=analysis_cache,

{sqlbuild-0.55.5 → sqlbuild-0.55.7}/src/sqlbuild/compiler/compile/_helpers/attachment/core.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import inspect
 import re
+from collections.abc import Callable
 from dataclasses import dataclass, fields, replace
 from datetime import UTC, datetime
 from inspect import Parameter, Signature
@@ -33,7 +34,7 @@ from sqlbuild.compiler.compile._helpers.config.model_validation import (
     validate_placeholder_config,
     validate_snapshot_config,
 )
-from sqlbuild.compiler.compile._helpers.refs.references import extract_sql_references
+from sqlbuild.compiler.compile._helpers.refs.cache import cached_sql_reference_extractor
 from sqlbuild.compiler.compile._helpers.render.cursor_intrinsics import (
     cursor_intrinsics_analysis_sql,
     get_validated_model_cursor_intrinsics,
@@ -124,9 +125,31 @@ def build_model_inputs(
     no_sql_validation: bool = False,
     defer_model_sql_validation: bool = False,
     external_sql_reference_resolver: ExternalSqlReferenceResolver | None = None,
+    reference_cache_dir: Path | None = None,
 ) -> tuple[CompileModelInput, ...]:
     """Attach schema metadata to discovered model files."""
 
+    with cached_sql_reference_extractor(root=reference_cache_dir) as extract_references:
+        return _build_model_inputs(
+            discovered_inputs=discovered_inputs,
+            context=context,
+            no_sql_validation=no_sql_validation,
+            defer_model_sql_validation=defer_model_sql_validation,
+            external_sql_reference_resolver=external_sql_reference_resolver,
+            extract_references=extract_references,
+        )
+
+
+def _build_model_inputs(
+    *,
+    discovered_inputs: DiscoveredProjectInputs,
+    context: ModelInputBuildContext,
+    no_sql_validation: bool,
+    defer_model_sql_validation: bool,
+    external_sql_reference_resolver: ExternalSqlReferenceResolver | None,
+    extract_references: Callable[[str], tuple[CompileSqlReference, ...]],
+) -> tuple[CompileModelInput, ...]:
+
     effective_vars: dict[str, object] = context.effective_vars
     effective_settings: SettingsConfig = context.effective_settings
     target_config: TargetConfig | None = context.target_config
@@ -223,7 +246,7 @@ def build_model_inputs(
                 file_path=model_file.file_path,
                 placeholders=sql_validation_placeholders,
             )
-        references: tuple[CompileSqlReference, ...] = extract_sql_references(expanded_query_sql)
+        references: tuple[CompileSqlReference, ...] = extract_references(expanded_query_sql)
         validate_model_references(
             references=references,
             model_file=model_file,

sqlbuild-0.55.7/src/sqlbuild/compiler/compile/_helpers/attachment/target.py

@@ -0,0 +1,49 @@
+"""Effective target and compile-cache resolution helpers."""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+from sqlbuild.compiler.compile.constants import (
+    COMPILE_CACHE_DISABLE_ENV_VAR,
+    COMPILE_CACHE_DISABLE_VALUE,
+)
+from sqlbuild.compiler.discovery.models import DiscoveredProjectInputs
+from sqlbuild.spec.contracts.main.resolve_target_config import resolve_target_config
+from sqlbuild.spec.contracts.main.resolve_target_name import resolve_target_name
+from sqlbuild.spec.contracts.models import TargetConfig
+
+
+def build_compile_target_context(
+    *,
+    discovered_inputs: DiscoveredProjectInputs,
+    selected_target: str | None,
+    no_cache: bool,
+) -> tuple[str | None, TargetConfig | None, Path | None]:
+    """Resolve the effective target and shared project-local compile-cache directory."""
+
+    target_name: str | None = resolve_target_name(
+        project_config=discovered_inputs.project_config,
+        local_config=discovered_inputs.local_config,
+        selected_target=selected_target,
+    )
+    target_config: TargetConfig | None = (
+        resolve_target_config(
+            project_config=discovered_inputs.project_config,
+            local_config=discovered_inputs.local_config,
+            target_name=target_name,
+        )
+        if target_name is not None
+        else None
+    )
+    cache_disabled: bool = (
+        no_cache
+        or (target_config is not None and target_config.compile_cache is False)
+        or os.environ.get(COMPILE_CACHE_DISABLE_ENV_VAR) == COMPILE_CACHE_DISABLE_VALUE
+    )
+    project_dir: Path | None = discovered_inputs.project_dir
+    cache_dir: Path | None = (
+        None if cache_disabled or project_dir is None else project_dir / "target" / "compile-cache"
+    )
+    return target_name, target_config, cache_dir