sqlbuild 0.82.1__tar.gz → 0.82.2__tar.gz

{sqlbuild-0.82.1 → sqlbuild-0.82.2}/Cargo.lock

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

{sqlbuild-0.82.1 → sqlbuild-0.82.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlbuild
-Version: 0.82.1
+Version: 0.82.2
 Requires-Dist: duckdb>=1.3.2
 Requires-Dist: filelock>=3.20.3
 Requires-Dist: polyglot-sql>=0.9.2

{sqlbuild-0.82.1 → sqlbuild-0.82.2}/crates/sqlbuild-kata-native/Cargo.toml

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

{sqlbuild-0.82.1 → sqlbuild-0.82.2}/pyproject.toml

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

{sqlbuild-0.82.1 → sqlbuild-0.82.2}/src/sqlbuild/adapter/state_sql/_helpers/source_freshness.py

@@ -16,9 +16,12 @@ from sqlbuild.compiler.source_freshness.constants import (
     COLUMN_TARGET_NAME,
     COLUMN_TARGET_SCHEMA,
     COLUMN_VALUE_KIND,
+    SOURCE_FRESHNESS_COLUMN_TYPES,
+    SOURCE_FRESHNESS_COLUMNS,
     SOURCE_FRESHNESS_TABLE_NAME,
 )
 from sqlbuild.compiler.source_freshness.models import SourceFreshnessRecord
+from sqlbuild.sql_values.main.render_state_literal import render_state_sql_literal
 
 
 def render_insert_source_freshness_records_sql(
@@ -55,28 +58,25 @@ def render_insert_source_freshness_records_sql(
 
 
 def _record_values_sql(record: SourceFreshnessRecord) -> str:
+    values: tuple[object | None, ...] = (
+        record.source_name,
+        record.target_database,
+        record.target_schema,
+        record.target_name,
+        record.run_id,
+        record.strategy,
+        record.value_kind,
+        record.data_version,
+        record.data_version_hash,
+        record.observed_at,
+    )
     return (
         "("
-        f"{_quote_sql_string(record.source_name)}, "
-        f"{_optional_string(record.target_database)}, "
-        f"{_optional_string(record.target_schema)}, "
-        f"{_optional_string(record.target_name)}, "
-        f"{_quote_sql_string(record.run_id)}, "
-        f"{_quote_sql_string(record.strategy)}, "
-        f"{_quote_sql_string(record.value_kind)}, "
-        f"{_optional_string(record.data_version)}, "
-        f"{_quote_sql_string(record.data_version_hash)}, "
-        f"{_quote_sql_string(record.observed_at.isoformat())}"
-        ")"
+        + ", ".join(
+            render_state_sql_literal(
+                value=value, declared_type=SOURCE_FRESHNESS_COLUMN_TYPES[column]
+            )
+            for column, value in zip(SOURCE_FRESHNESS_COLUMNS, values, strict=True)
+        )
+        + ")"
     )
-
-
-def _optional_string(value: str | None) -> str:
-    if value is None:
-        return "NULL"
-    return _quote_sql_string(value)
-
-
-def _quote_sql_string(value: str) -> str:
-    escaped_value: str = value.replace("'", "''")
-    return f"'{escaped_value}'"

{sqlbuild-0.82.1 → sqlbuild-0.82.2}/src/sqlbuild/cli/commands/_helpers/cost/command.py

@@ -27,6 +27,8 @@ from sqlbuild.cli.commands.models import CostCommandRequest
 from sqlbuild.cost.classes.run_cost_store import RunCostStore
 from sqlbuild.cost.models import CostRunRecord, ResourceCost
 from sqlbuild.cost.types import CostStatus
+from sqlbuild.cursor_algebra.constants import MINUTE_TO_DAY_DURATION_UNITS
+from sqlbuild.cursor_algebra.models import Duration
 from sqlbuild.presentation.main.supports_color import supports_color
 
 _HISTORY_SORT_FIELDS: frozenset[str] = frozenset(
@@ -35,8 +37,6 @@ _HISTORY_SORT_FIELDS: frozenset[str] = frozenset(
 _BREAKDOWN_SORT_FIELDS: frozenset[str] = frozenset(
     {"cost", "credits", "busy", "scanned", "model", "warehouse"}
 )
-_RELATIVE_SINCE_PATTERN: re.Pattern[str] = re.compile(r"^(?P<amount>\d+)(?P<unit>[dhm])$")
-_RELATIVE_SECONDS_BY_UNIT: dict[str, int] = {"d": 86_400, "h": 3_600, "m": 60}
 _MISSING_METRIC_STATUSES: frozenset[CostStatus] = frozenset(
     {
         CostStatus.PENDING,
@@ -46,6 +46,7 @@ _MISSING_METRIC_STATUSES: frozenset[CostStatus] = frozenset(
     }
 )
 _HISTORY_METRIC_SORT_FIELDS: frozenset[str] = frozenset({"cost", "credits"})
+_ZERO_DURATION_PATTERN: re.Pattern[str] = re.compile(r"^0+[dhm]$")
 
 
 def run_cost_command(request: CostCommandRequest) -> int:
@@ -205,12 +206,14 @@ def _parse_bound(*, value: str | None, label: str, end_of_day: bool) -> datetime
 def _parse_since_bound(*, value: str | None) -> datetime | None:
     if value is None:
         return None
-    match: re.Match[str] | None = _RELATIVE_SINCE_PATTERN.fullmatch(value)
-    if match is None:
+    if _ZERO_DURATION_PATTERN.fullmatch(value) is not None:
+        return datetime.now(UTC)
+    duration: Duration | None = Duration.parse(value)
+    if duration is None:
         return _parse_bound(value=value, label="--since", end_of_day=False)
-    amount: int = int(match.group("amount"))
-    seconds: int = amount * _RELATIVE_SECONDS_BY_UNIT[match.group("unit")]
-    return datetime.now(UTC) - timedelta(seconds=seconds)
+    if not duration.is_single_unit_in(MINUTE_TO_DAY_DURATION_UNITS):
+        raise CliUserError("cost --since relative duration must use one of: d, h, m", code="C707")
+    return datetime.now(UTC) - timedelta(seconds=duration.fixed_seconds)
 
 
 def _sort_history_records(

{sqlbuild-0.82.1 → sqlbuild-0.82.2}/src/sqlbuild/cli/commands/_helpers/entry/dispatch_errors.py

@@ -21,6 +21,7 @@ from sqlbuild.compiler.discovery.exceptions import DiscoveryError
 from sqlbuild.executor.pipeline.exceptions import AuditExecutionError
 from sqlbuild.kata_engine.exceptions import KataError
 from sqlbuild.lint.exceptions import LintError
+from sqlbuild.spec.contracts.exceptions import SpecConfigError
 from sqlbuild.virtual.state.exceptions import StateBackendError
 
 
@@ -51,7 +52,13 @@ def dispatch_and_handle_errors(
             file=sys.stderr,
         )
         return 1
-    except (AuditExecutionError, DiscoveryError, StateBackendError, ValueError) as error:
+    except (
+        AuditExecutionError,
+        DiscoveryError,
+        SpecConfigError,
+        StateBackendError,
+        ValueError,
+    ) as error:
         logging.getLogger("sqlbuild.cli").exception("command failed")
         print(
             format_expected_error(error=error, fallback_code="E001", use_color=use_color),

{sqlbuild-0.82.1 → sqlbuild-0.82.2}/src/sqlbuild/cli/commands/_helpers/load/invocation.py

@@ -6,15 +6,20 @@ import sys
 from pathlib import Path
 from typing import TextIO
 
+from sqlbuild.adapter.contract.types import BuiltinAdapter
 from sqlbuild.cli.commands._helpers.load.selection import (
     select_load_entries,
     select_load_reference_entries,
 )
 from sqlbuild.cli.commands.models import LoadCommandRequest, LoadInvocation
+from sqlbuild.compiler.compile.main.effective_config import build_effective_connection_config
 from sqlbuild.compiler.compile.main.effective_target import build_effective_target_config
 from sqlbuild.compiler.discovery.main.discover import discover_project_inputs
 from sqlbuild.compiler.discovery.models import DiscoveredProjectInputs
 from sqlbuild.presentation.main.supports_color import supports_color
+from sqlbuild.spec.contracts.main.resolve_effective_adapter_name import (
+    resolve_effective_adapter_name,
+)
 from sqlbuild.spec.contracts.models import SourceEntry, TargetConfig
 
 
@@ -31,16 +36,26 @@ def resolve_load_invocation(*, request: LoadCommandRequest) -> LoadInvocation:
         discovered_inputs=discovered_inputs,
         selected_target=request.selected_target,
     )
+    loader_default_database, loader_default_schema = _effective_loader_defaults(
+        discovered_inputs=discovered_inputs,
+        selected_target=request.selected_target,
+        target_config=target_config,
+        cli_vars=request.cli_vars,
+    )
     selected_sources: tuple[SourceEntry, ...] = select_load_entries(
         discovered_inputs=discovered_inputs,
         select=request.select,
         exclude=request.exclude,
         target_config=target_config,
+        loader_default_database=loader_default_database,
+        loader_default_schema=loader_default_schema,
     )
     reference_sources: tuple[SourceEntry, ...] = select_load_reference_entries(
         discovered_inputs=discovered_inputs,
         selected_sources=selected_sources,
         target_config=target_config,
+        loader_default_database=loader_default_database,
+        loader_default_schema=loader_default_schema,
     )
     machine_output: bool = request.json_output
     use_color: bool = not request.no_color and not machine_output and supports_color()
@@ -53,3 +68,35 @@ def resolve_load_invocation(*, request: LoadCommandRequest) -> LoadInvocation:
         use_color=use_color,
         progress_stream=progress_stream,
     )
+
+
+def _effective_loader_defaults(
+    *,
+    discovered_inputs: DiscoveredProjectInputs,
+    selected_target: str | None,
+    target_config: TargetConfig | None,
+    cli_vars: dict[str, object] | None,
+) -> tuple[str | None, str | None]:
+    connection: dict[str, object] = build_effective_connection_config(
+        discovered_inputs=discovered_inputs,
+        selected_target=selected_target,
+        cli_vars=cli_vars,
+    )
+    connection_database: str | None = _non_empty_string(connection.get("database"))
+    if (
+        resolve_effective_adapter_name(
+            project_config=discovered_inputs.project_config,
+            local_config=discovered_inputs.local_config,
+        )
+        == BuiltinAdapter.DUCKDB
+    ):
+        connection_database = None
+    return (
+        (target_config.database if target_config is not None else None) or connection_database,
+        (target_config.schema if target_config is not None else None)
+        or _non_empty_string(connection.get("schema")),
+    )
+
+
+def _non_empty_string(value: object) -> str | None:
+    return value.strip() if isinstance(value, str) and value.strip() else None

{sqlbuild-0.82.1 → sqlbuild-0.82.2}/src/sqlbuild/cli/commands/_helpers/load/selection.py

@@ -8,7 +8,8 @@ from sqlbuild.cli.commands.exceptions import CliUserError
 from sqlbuild.cli.commands.models import LoadSelectionSets, LoadSelectorSets
 from sqlbuild.compiler.discovery.models import DiscoveredLoaderFunction, DiscoveredProjectInputs
 from sqlbuild.compiler.graph.main.transitive_closure import transitive_closure
-from sqlbuild.spec.contracts.models import SourceEntry, TargetConfig
+from sqlbuild.spec.contracts.main.loader_destination_parts import loader_destination_parts
+from sqlbuild.spec.contracts.models import LoaderDestinationParts, SourceEntry, TargetConfig
 
 
 def select_load_entries(
@@ -17,6 +18,8 @@ def select_load_entries(
     select: tuple[str, ...],
     exclude: tuple[str, ...],
     target_config: TargetConfig | None,
+    loader_default_database: str | None = None,
+    loader_default_schema: str | None = None,
 ) -> tuple[SourceEntry, ...]:
     """Select source and intermediate loader execution entries for sqb load."""
 
@@ -99,7 +102,11 @@ def select_load_entries(
     ):
         if loader_name not in selected_terminal_loaders:
             entries.append(
-                _loader_to_source_entry(loader=loaders[loader_name], target_config=target_config)
+                _loader_to_source_entry(
+                    loader=loaders[loader_name],
+                    default_database=loader_default_database,
+                    default_schema=loader_default_schema,
+                )
             )
     entries.extend(
         managed_sources[source_name]
@@ -113,6 +120,8 @@ def select_load_reference_entries(
     discovered_inputs: DiscoveredProjectInputs,
     selected_sources: tuple[SourceEntry, ...],
     target_config: TargetConfig | None,
+    loader_default_database: str | None = None,
+    loader_default_schema: str | None = None,
 ) -> tuple[SourceEntry, ...]:
     """Return unselected upstream intermediate loader entries used only for refs."""
 
@@ -143,7 +152,11 @@ def select_load_reference_entries(
                 )
             )
     return tuple(
-        _loader_to_source_entry(loader=loaders[loader_name], target_config=target_config)
+        _loader_to_source_entry(
+            loader=loaders[loader_name],
+            default_database=loader_default_database,
+            default_schema=loader_default_schema,
+        )
         for loader_name in _topological_loader_order(
             loader_names=reference_loader_names,
             upstream_loaders=upstream_loaders,
@@ -409,28 +422,21 @@ def _environment_sources(
 def _loader_to_source_entry(
     *,
     loader: DiscoveredLoaderFunction,
-    target_config: TargetConfig | None,
+    default_database: str | None,
+    default_schema: str | None,
 ) -> SourceEntry:
-    database: str | None = target_config.database if target_config is not None else None
-    schema: str | None = target_config.schema if target_config is not None else None
-    table: str = f"__loader__{loader.name}"
-    if loader.destination is not None:
-        parts: tuple[str, ...] = tuple(part for part in loader.destination.split(".") if part)
-        if len(parts) == 1:
-            table = parts[0]
-        source_name_part_count: int = 2
-        qualified_source_name_part_count: int = 3
-        if len(parts) == source_name_part_count:
-            schema, table = parts
-        elif len(parts) == qualified_source_name_part_count:
-            database, schema, table = parts
-        else:
-            table = loader.destination
+    destination: LoaderDestinationParts = loader_destination_parts(
+        destination=(
+            loader.destination if loader.destination is not None else f"__loader__{loader.name}"
+        ),
+        default_database=default_database,
+        default_schema=default_schema,
+    )
     return SourceEntry(
         name=loader.name,
-        database=database,
-        schema=schema,
-        table=table,
+        database=destination.database,
+        schema=destination.schema,
+        table=destination.table,
         loader=loader.name,
         write_strategy=loader.write_strategy,
         cursor_column=loader.cursor_column,

{sqlbuild-0.82.1 → sqlbuild-0.82.2}/src/sqlbuild/cli/output/_helpers/integration_result.py

@@ -22,7 +22,7 @@ from sqlbuild.cli.output.models import (
     IntegrationResultEnvelope,
 )
 from sqlbuild.cli.output.types import IntegrationOutputKind
-from sqlbuild.compiler.auditing.types import AuditOutcome
+from sqlbuild.compiler.auditing.types import AuditOutcome, AuditSeverity
 from sqlbuild.compiler.compile.types import CompiledResourceType
 from sqlbuild.compiler.planner.models import PlanOutput
 from sqlbuild.executor.auditing.main.resource_id import audit_resource_id
@@ -349,7 +349,7 @@ def _check_results(*, result: object) -> tuple[IntegrationCheckResult, ...]:
                 dag_check_id=f"check:{result.node_name}",
                 passed=result.passed,
                 status=status,
-                severity=result.severity.value,
+                severity=AuditSeverity(result.severity.value),
             ),
         )
     return ()
@@ -363,7 +363,7 @@ def _audit_result(result: AuditExecutionResult) -> IntegrationCheckResult:
         dag_check_id=_audit_check_id(result),
         passed=result.outcome == AuditOutcome.PASS,
         status=result.outcome.value,
-        severity=result.severity.value,
+        severity=result.severity,
         row_count=result.row_count,
         attachment_kind=result.attachment_kind.value,
         asset_name=result.attached_target_name,

{sqlbuild-0.82.1 → sqlbuild-0.82.2}/src/sqlbuild/cli/output/models.py

@@ -50,6 +50,7 @@ from sqlbuild.cli.output.types import (
     CursorResolutionStatus,
     IntegrationOutputKind,
 )
+from sqlbuild.compiler.auditing.types import AuditSeverity
 from sqlbuild.compiler.planner.models import CursorBounds
 from sqlbuild.runtime.observability.constants import (
     RESOURCE_ATTEMPT_SKIPPED_EVENT,
@@ -181,7 +182,7 @@ class IntegrationCheckResult:
     passed: bool
     status: str
     dag_check_id: str | None = None
-    severity: str | None = None
+    severity: AuditSeverity | None = None
     asset_name: str | None = None
     attachment_kind: str | None = None
     attached_column_name: str | None = None
@@ -360,6 +361,9 @@ class IntegrationResultEnvelope:
 
         payload: dict[str, Any] = asdict(self)
         payload["output_kind"] = self.output_kind.value
+        for check_payload, check in zip(payload["checks"], self.checks, strict=True):
+            if check.severity is not None:
+                check_payload["severity"] = check.severity.value
         return encode_integration_json(value=payload, record=True) + "\n"
 
     def _validate_result_identity(self) -> None:
@@ -449,11 +453,22 @@ class IntegrationResultEnvelope:
             asset: IntegrationAssetResult | None = (
                 IntegrationAssetResult(**asset_payload) if isinstance(asset_payload, dict) else None
             )
-            checks: tuple[IntegrationCheckResult, ...] = tuple(
-                IntegrationCheckResult(**check_payload)
-                for check_payload in checks_payload
-                if isinstance(check_payload, dict)
-            )
+            parsed_checks: list[IntegrationCheckResult] = []
+            for check_payload in checks_payload:
+                if not isinstance(check_payload, dict):
+                    continue
+                severity_value: object = check_payload.pop("severity", None)
+                severity: AuditSeverity | None = None
+                if severity_value is not None:
+                    try:
+                        severity = AuditSeverity(severity_value)
+                    except (TypeError, ValueError) as error:
+                        allowed: str = ", ".join(item.value for item in AuditSeverity)
+                        raise ObservabilityValidationError(
+                            f"integration check severity must be one of: {allowed}"
+                        ) from error
+                parsed_checks.append(IntegrationCheckResult(**check_payload, severity=severity))
+            checks: tuple[IntegrationCheckResult, ...] = tuple(parsed_checks)
             if len(checks) != len(checks_payload):
                 raise ObservabilityValidationError(
                     "integration result checks must contain only objects"

{sqlbuild-0.82.1 → sqlbuild-0.82.2}/src/sqlbuild/compiler/auditing/_helpers/identity.py

@@ -35,7 +35,7 @@ def audit_identity(audit: AuditPlanEntry) -> AuditIdentity:
         audit_name=audit.name,
         definition_fingerprint=hash_payload(definition_payload),
         execution_fingerprint=hash_payload(execution_identity_payload),
-        severity=audit.severity.value,
+        severity=audit.severity,
         run_scope_phase=audit.effective_run_scope.value,
         attachment_kind=audit.attachment_kind.value,
         attached_target_name=audit.attached_target_name,
@@ -50,7 +50,7 @@ def binding_payload(audit: AuditIdentity) -> dict[str, object]:
     return {
         "binding_key": audit.binding_key,
         "audit_name": audit.audit_name,
-        "severity": audit.severity,
+        "severity": audit.severity.value,
         "run_scope_phase": audit.run_scope_phase,
         "attachment_kind": audit.attachment_kind,
         "attached_target_name": audit.attached_target_name,

{sqlbuild-0.82.1 → sqlbuild-0.82.2}/src/sqlbuild/compiler/auditing/_helpers/schema_audits.py

@@ -6,6 +6,7 @@ from pathlib import Path
 from typing import cast
 
 from sqlbuild.compiler.auditing.constants import SCHEMA_AUDIT_OPTION_KEYS
+from sqlbuild.compiler.auditing.types import AuditSeverity
 from sqlbuild.compiler.resource_names.main._validate_resource_identity import (
     validate_resource_identity,
 )
@@ -74,13 +75,22 @@ def parse_audit_instance_impl(
         key="description",
         error_class=error_class,
     )
-    severity: str | None = _optional_named_string(
+    raw_severity: str | None = _optional_named_string(
         raw_value=argument_mapping.get("severity"),
         file_path=file_path,
         label=option_label,
         key="severity",
         error_class=error_class,
     )
+    severity: AuditSeverity | None = None
+    if raw_severity is not None:
+        try:
+            severity = AuditSeverity(raw_severity)
+        except ValueError as error:
+            allowed: str = ", ".join(item.value for item in AuditSeverity)
+            raise error_class(
+                f"{file_path} {option_label} 'severity' must be one of: {allowed}"
+            ) from error
     run_scope: str | None = _optional_named_string(
         raw_value=argument_mapping.get("run_scope"),
         file_path=file_path,

{sqlbuild-0.82.1 → sqlbuild-0.82.2}/src/sqlbuild/compiler/auditing/main/identity.py

@@ -27,7 +27,7 @@ def build_audit_gate_identity(*, audits: tuple[AuditPlanEntry, ...]) -> AuditGat
     blocking_payloads: tuple[dict[str, object], ...] = tuple(
         execution_payload(audit)
         for audit in audit_identities
-        if audit.severity == AuditSeverity.ERROR.value
+        if audit.severity == AuditSeverity.ERROR
     )
     return AuditGateIdentity(
         binding_set_hash=hash_payload(binding_payloads),

{sqlbuild-0.82.1 → sqlbuild-0.82.2}/src/sqlbuild/compiler/auditing/models.py

@@ -4,6 +4,8 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 
+from sqlbuild.compiler.auditing.types import AuditSeverity
+
 
 @dataclass(frozen=True)
 class AuditIdentity:
@@ -13,7 +15,7 @@ class AuditIdentity:
     audit_name: str
     definition_fingerprint: str
     execution_fingerprint: str
-    severity: str
+    severity: AuditSeverity
     run_scope_phase: str
     attachment_kind: str
     attached_target_name: str | None = None

{sqlbuild-0.82.1 → sqlbuild-0.82.2}/src/sqlbuild/compiler/compile/_helpers/attachment/audits.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 from dataclasses import dataclass
 from pathlib import Path
 
+from sqlbuild.compiler.auditing.types import AuditSeverity
 from sqlbuild.compiler.compile._helpers.attachment.references import (
     build_known_ref_names,
     build_known_seed_names,
@@ -64,7 +65,7 @@ class _AuditAttachmentContext:
     known_model_names: set[str]
     known_seed_names: set[str]
     known_source_names: set[str]
-    default_audit_severity: str | None
+    default_audit_severity: AuditSeverity | None
     default_audit_run_scope: str | None
     effective_vars: dict[str, object]
     macro_context: MacroContext
@@ -98,7 +99,7 @@ def build_audit_inputs(
     known_source_names: set[str] = build_known_source_names(discovered_inputs)
     if generic_audit_definitions is None:
         generic_audit_definitions = index_generic_audit_definitions(discovered_inputs.audit_files)
-    default_audit_severity: str | None = effective_settings.default_audit_severity
+    default_audit_severity: AuditSeverity | None = effective_settings.default_audit_severity
     default_audit_run_scope: str | None = effective_settings.default_audit_run_scope
     attachment_context: _AuditAttachmentContext = _AuditAttachmentContext(
         generic_audit_definitions=generic_audit_definitions,
@@ -160,7 +161,7 @@ def build_audit_inputs(
             header_always_run: bool = _bool_from_dict(
                 values=audit_block.header_values, key="always_run"
             )
-            resolved_severity: str = resolve_audit_severity(
+            resolved_severity: AuditSeverity = resolve_audit_severity(
                 instance_severity=header_severity,
                 default_severity=default_audit_severity,
                 audit_label=str(audit_file.relative_path),
@@ -386,7 +387,7 @@ def build_attached_audit_input(
         known_source_names=context.known_source_names,
     )
     audit_label: str = f"{owner_file} audit '{audit_instance.definition_name}'"
-    resolved_severity: str = resolve_audit_severity(
+    resolved_severity: AuditSeverity = resolve_audit_severity(
         instance_severity=audit_instance.severity,
         default_severity=context.default_audit_severity,
         audit_label=audit_label,
@@ -531,30 +532,29 @@ def render_generic_audit_argument_value(
 
 def resolve_audit_severity(
     *,
-    instance_severity: str | None,
-    default_severity: str | None,
+    instance_severity: str | AuditSeverity | None,
+    default_severity: str | AuditSeverity | None,
     audit_label: str,
-) -> str:
+) -> AuditSeverity:
     """Resolve audit severity from instance, project default, or error fallback."""
 
-    from sqlbuild.compiler.auditing.types import AuditSeverity
-
-    valid_values: frozenset[str] = frozenset(s.value for s in AuditSeverity)
+    valid_values: tuple[str, ...] = tuple(severity.value for severity in AuditSeverity)
     if instance_severity is not None:
-        if instance_severity not in valid_values:
+        try:
+            return AuditSeverity(instance_severity)
+        except ValueError as error:
             raise CompileInputError(
                 f"{audit_label}: unknown severity '{instance_severity}'; "
-                f"valid values: {', '.join(sorted(valid_values))}"
-            )
-        return instance_severity
+                f"valid values: {', '.join(valid_values)}"
+            ) from error
     if default_severity is not None:
-        if default_severity not in valid_values:
+        try:
+            return AuditSeverity(default_severity)
+        except ValueError as error:
             raise CompileInputError(
-                f"settings.default_audit_severity in sqlbuild_project.toml: "
-                f"unknown value '{default_severity}'; "
-                f"valid values: {', '.join(sorted(valid_values))}"
-            )
-        return default_severity
+                "settings.default_audit_severity in sqlbuild_project.toml: "
+                f"unknown value '{default_severity}'; valid values: {', '.join(valid_values)}"
+            ) from error
     return AuditSeverity.ERROR