contractforge-databricks 0.1.0__py3-none-any.whl

contractforge_databricks/preparation/shape.py

@@ -0,0 +1,209 @@
+"""Optional PySpark execution for declarative shape intent."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from contractforge_databricks.preparation.shape_validation import (
+    CARDINALITY_CHANGING_MODES,
+    as_dict,
+    as_list,
+    data_type_at_path,
+    flatten_config,
+    is_excluded,
+    path_col,
+    validate_cardinality_policy,
+    validate_cartesian_arrays,
+    validate_columns,
+)
+from contractforge_databricks.preparation.zip_arrays import apply_zip_arrays
+
+
+def apply_shape(df: Any, shape: dict[str, Any] | None, *, layer: str = "silver") -> Any:
+    """Apply portable shape intent with PySpark DataFrame operations."""
+
+    if not shape:
+        return df
+    validate_cardinality_policy(shape, layer)
+    validate_cartesian_arrays(shape)
+    df = _apply_parse_json(df, as_list(shape.get("parse_json")))
+    df = apply_zip_arrays(df, as_list(shape.get("zip_arrays")))
+    df = _apply_arrays(df, as_list(shape.get("arrays")))
+    df = _drop_shape_intermediates(df, shape)
+    df = _apply_columns(df, as_dict(shape.get("columns")))
+    return _apply_flatten(df, shape.get("flatten"))
+
+
+def _apply_parse_json(df: Any, configs: list[dict[str, Any]]) -> Any:
+    from pyspark.sql import functions as F
+    from pyspark.sql.types import StringType
+
+    for config in configs:
+        column = str(config["column"])
+        validate_columns(df, {column: True}, "shape.parse_json")
+        cast_input = str(config.get("cast_input") or "").strip().upper()
+        source_expr = path_col(F, column)
+        if cast_input == "STRING":
+            source_expr = source_expr.cast("string")
+        elif cast_input:
+            raise ValueError(f"shape.parse_json.{column}.cast_input={cast_input!r} is not supported")
+        else:
+            data_type = data_type_at_path(getattr(df, "schema", None), column)
+            if data_type is not None and not isinstance(data_type, StringType):
+                raise ValueError(
+                    f"shape.parse_json.{column} must be string;"
+                    " declare cast_input: STRING to coerce a binary/non-string source column"
+                )
+        schema = config.get("schema")
+        if not schema:
+            raise ValueError("shape.parse_json requires schema for runtime execution")
+        alias = str(config.get("alias") or column)
+        df = df.withColumn(alias, F.from_json(source_expr, str(schema)))
+        if config.get("drop_source") and alias != column:
+            df = df.drop(column)
+    return df
+
+
+def _apply_arrays(df: Any, arrays: list[dict[str, Any]]) -> Any:
+    from pyspark.sql import functions as F
+    from pyspark.sql.types import ArrayType
+
+    pending = [config for config in arrays if str(config.get("mode", "keep")) != "keep"]
+    while pending:
+        progressed = False
+        remaining = []
+        for config in pending:
+            top_level = str(config["path"]).split(".", 1)[0]
+            if top_level not in set(getattr(df, "columns", ()) or ()):
+                remaining.append(config)
+                continue
+            df = _apply_array_config(df, config, F, ArrayType)
+            progressed = True
+        if not progressed:
+            unresolved = [str(config["path"]) for config in remaining]
+            raise ValueError(f"shape.arrays contains unresolved paths: {unresolved}")
+        pending = remaining
+    return df
+
+
+def _apply_array_config(df: Any, config: dict[str, Any], functions: Any, array_type: Any) -> Any:
+        mode = str(config.get("mode", "keep"))
+        path = str(config["path"])
+        data_type = data_type_at_path(getattr(df, "schema", None), path)
+        if data_type is not None and not isinstance(data_type, array_type):
+            raise ValueError(f"shape.arrays.{path} must be array")
+        alias = str(config.get("alias") or path.replace(".", "_"))
+        column = path_col(functions, path)
+        if mode == "to_json":
+            expr = functions.to_json(column)
+        elif mode == "size":
+            expr = functions.size(column)
+        elif mode == "first":
+            expr = functions.element_at(column, 1)
+        elif mode == "explode":
+            expr = functions.explode(column)
+        elif mode == "explode_outer":
+            expr = functions.explode_outer(column)
+        else:
+            raise ValueError(f"shape.arrays mode {mode!r} is not supported")
+        return df.withColumn(alias, expr)
+
+
+def _apply_columns(df: Any, columns: dict[str, Any]) -> Any:
+    if not columns:
+        return df
+    from pyspark.sql import functions as F
+
+    projected = []
+    for path, config in columns.items():
+        if isinstance(config, str):
+            alias = config
+            expr = path_col(F, str(path))
+        else:
+            alias = str(config.get("alias") or str(path).replace(".", "_"))
+            expr = F.expr(str(config["expression"])) if config.get("expression") else path_col(F, str(path))
+            if config.get("cast"):
+                expr = expr.cast(str(config["cast"]))
+        projected.append(expr.alias(str(alias)))
+    return df.select(*projected)
+
+
+def _apply_flatten(df: Any, flatten: object) -> Any:
+    config = flatten_config(flatten)
+    if not config["enabled"]:
+        return df
+    from pyspark.sql.types import StructType
+    from pyspark.sql import functions as F
+
+    projections = []
+    aliases = set()
+    top_level = set(getattr(df, "columns", ()) or ())
+    separator = str(config["separator"])
+    max_depth = int(config["max_depth"])
+    include = set(config["include"])
+    exclude = set(config["exclude"])
+    for field in getattr(getattr(df, "schema", None), "fields", ()):
+        if include and field.name not in include:
+            projections.append(path_col(F, field.name).alias(field.name))
+            aliases.add(field.name)
+            continue
+        if is_excluded(field.name, exclude):
+            projections.append(path_col(F, field.name).alias(field.name))
+            aliases.add(field.name)
+            continue
+        if isinstance(field.dataType, StructType):
+            for path, alias in _struct_leaf_paths(field.dataType, field.name, separator, max_depth=max_depth):
+                if is_excluded(path, exclude):
+                    continue
+                if alias in top_level:
+                    continue
+                if alias in aliases:
+                    raise ValueError(f"shape.flatten would create duplicate column: {alias}")
+                projections.append(path_col(F, path).alias(alias))
+                aliases.add(alias)
+        else:
+            if field.name in aliases:
+                raise ValueError(f"shape.flatten would create duplicate column: {field.name}")
+            projections.append(path_col(F, field.name).alias(field.name))
+            aliases.add(field.name)
+    return df.select(*projections) if projections else df
+
+
+def _drop_shape_intermediates(df: Any, shape: dict[str, Any]) -> Any:
+    if shape.get("columns"):
+        return df
+    arrays = as_list(shape.get("arrays"))
+    array_paths = [str(item["path"]) for item in arrays]
+    zip_aliases = {
+        str(config["alias"])
+        for config in as_list(shape.get("zip_arrays"))
+        if any(path == str(config["alias"]) or path.startswith(f"{config['alias']}.") for path in array_paths)
+    }
+    exploded_aliases = {
+        str(item.get("alias") or str(item["path"]).replace(".", "_"))
+        for item in arrays
+        if item.get("mode") in CARDINALITY_CHANGING_MODES
+        and any(
+            path != str(item["path"])
+            and (
+                path == str(item.get("alias") or str(item["path"]).replace(".", "_"))
+                or path.startswith(f"{item.get('alias') or str(item['path']).replace('.', '_')}.")
+            )
+            for path in array_paths
+        )
+    }
+    to_drop = sorted((zip_aliases | exploded_aliases) & set(getattr(df, "columns", ()) or ()))
+    return df.drop(*to_drop) if to_drop else df
+
+
+def _struct_leaf_paths(struct: Any, prefix: str, separator: str, *, max_depth: int, depth: int = 1) -> list[tuple[str, str]]:
+    from pyspark.sql.types import StructType
+
+    leaves = []
+    for field in struct.fields:
+        path = f"{prefix}.{field.name}"
+        if isinstance(field.dataType, StructType) and depth < max_depth:
+            leaves.extend(_struct_leaf_paths(field.dataType, path, separator, max_depth=max_depth, depth=depth + 1))
+        else:
+            leaves.append((path, path.replace(".", separator)))
+    return leaves

contractforge_databricks/preparation/shape_validation.py

@@ -0,0 +1,94 @@
+"""Validation helpers for Databricks shape execution."""
+
+from __future__ import annotations
+
+from typing import Any
+
+CARDINALITY_CHANGING_MODES = frozenset({"explode", "explode_outer"})
+
+
+def validate_cardinality_policy(shape: dict[str, Any], layer: str) -> None:
+    if layer != "bronze" or shape.get("allow_cardinality_change_on_bronze"):
+        return
+    changing = [item["path"] for item in as_list(shape.get("arrays")) if item.get("mode") in CARDINALITY_CHANGING_MODES]
+    if changing:
+        raise ValueError(f"shape cardinality change is blocked in bronze by default: {changing}")
+
+
+def validate_cartesian_arrays(shape: dict[str, Any]) -> None:
+    groups: dict[str, list[dict[str, Any]]] = {}
+    for item in as_list(shape.get("arrays")):
+        if item.get("mode") not in CARDINALITY_CHANGING_MODES:
+            continue
+        groups.setdefault(parent_path(str(item["path"])), []).append(item)
+    conflicts = {
+        parent: [str(item["path"]) for item in items if not item.get("allow_cartesian")]
+        for parent, items in groups.items()
+        if len(items) > 1 and any(not item.get("allow_cartesian") for item in items)
+    }
+    if conflicts:
+        raise ValueError(f"shape contains sibling explodes that may create a cartesian product: {conflicts}")
+
+
+def validate_columns(df: Any, columns: dict[str, Any], context: str) -> None:
+    available = set(getattr(df, "columns", ()) or ())
+    missing = sorted(str(column) for column in columns if str(column).split(".", 1)[0] not in available)
+    if missing:
+        raise ValueError(f"{context} references missing columns: {missing}")
+
+
+def data_type_at_path(schema: Any, path: str) -> Any | None:
+    from pyspark.sql.types import ArrayType, StructType
+
+    current = schema
+    for part in path.split("."):
+        if isinstance(current, ArrayType):
+            current = current.elementType
+        if not isinstance(current, StructType):
+            return None
+        field = next((item for item in current.fields if item.name == part), None)
+        if field is None:
+            return None
+        current = field.dataType
+    return current
+
+
+def flatten_config(flatten: object) -> dict[str, Any]:
+    if isinstance(flatten, bool):
+        return {"enabled": flatten, "separator": "_", "max_depth": 10, "include": [], "exclude": []}
+    config = as_dict(flatten)
+    return {
+        "enabled": bool(config.get("enabled", False)),
+        "separator": config.get("separator", "_"),
+        "max_depth": config.get("max_depth", 10),
+        "include": string_list(config.get("include")),
+        "exclude": string_list(config.get("exclude")),
+    }
+
+
+def path_col(functions: Any, path: str) -> Any:
+    return functions.col(".".join(f"`{part}`" for part in path.split(".")))
+
+
+def parent_path(path: str) -> str:
+    return ".".join(path.split(".")[:-1])
+
+
+def is_excluded(path: str, exclude: set[str]) -> bool:
+    return path in exclude or any(path.startswith(f"{item}.") for item in exclude)
+
+
+def as_dict(value: object) -> dict[str, Any]:
+    return dict(value) if isinstance(value, dict) else {}
+
+
+def as_list(value: object) -> list[dict[str, Any]]:
+    return [dict(item) for item in value or () if isinstance(item, dict)]
+
+
+def string_list(value: object) -> list[str]:
+    if value is None:
+        return []
+    if isinstance(value, str):
+        return [value]
+    return [str(item) for item in value]  # type: ignore[union-attr]

contractforge_databricks/preparation/staging.py

@@ -0,0 +1,17 @@
+"""Compatibility exports for platform-neutral staging specifications."""
+
+from contractforge_core.preparation import (
+    HashDiffStageSpec,
+    SCD2StageSpec,
+    SnapshotStageSpec,
+    scd2_stage_spec_from_contract,
+    snapshot_stage_spec_from_contract,
+)
+
+__all__ = [
+    "HashDiffStageSpec",
+    "SCD2StageSpec",
+    "SnapshotStageSpec",
+    "scd2_stage_spec_from_contract",
+    "snapshot_stage_spec_from_contract",
+]

contractforge_databricks/preparation/zip_arrays.py

@@ -0,0 +1,51 @@
+"""PySpark execution for shape.zip_arrays."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from contractforge_databricks.preparation.shape_validation import as_dict, data_type_at_path, path_col, validate_columns
+
+
+def apply_zip_arrays(df: Any, configs: list[dict[str, Any]]) -> Any:
+    """Zip parallel arrays and rename struct fields according to the contract."""
+
+    from pyspark.sql import functions as F
+    from pyspark.sql.types import ArrayType
+
+    aliases = set(getattr(df, "columns", ()) or ())
+    for config_idx, config in enumerate(configs):
+        alias = str(config["alias"])
+        if alias in aliases:
+            raise ValueError(f"shape.zip_arrays would collide with existing column: {alias}")
+        columns = as_dict(config.get("columns"))
+        if not columns:
+            raise ValueError("shape.zip_arrays.columns is required")
+        validate_columns(df, {path: True for path in columns}, "shape.zip_arrays")
+        temp_columns = []
+        for path, field_alias in columns.items():
+            data_type = data_type_at_path(getattr(df, "schema", None), path)
+            if data_type is not None and not isinstance(data_type, ArrayType):
+                raise ValueError(f"shape.zip_arrays.{path} must be array")
+            temp = _unique_temp_column(getattr(df, "columns", ()) or (), f"__cf_shape_zip_{config_idx}_{len(temp_columns)}")
+            df = df.withColumn(temp, path_col(F, str(path)))
+            temp_columns.append((temp, str(field_alias)))
+
+        zipped = F.arrays_zip(*[F.col(temp) for temp, _ in temp_columns])
+        renamed = F.transform(
+            zipped,
+            lambda item: F.struct(*[item.getField(temp).alias(field_alias) for temp, field_alias in temp_columns]),
+        )
+        df = df.withColumn(alias, renamed).drop(*[temp for temp, _ in temp_columns])
+        aliases.add(alias)
+    return df
+
+
+def _unique_temp_column(columns: object, prefix: str) -> str:
+    existing = set(columns or ())
+    candidate = prefix
+    idx = 0
+    while candidate in existing:
+        idx += 1
+        candidate = f"{prefix}_{idx}"
+    return candidate

contractforge_databricks/presets/__init__.py

@@ -0,0 +1,3 @@
+from contractforge_databricks.presets.core import apply_preset, get_preset, list_presets, preset_details, register_preset
+
+__all__ = ["apply_preset", "get_preset", "list_presets", "preset_details", "register_preset"]

contractforge_databricks/presets/base.py

@@ -0,0 +1,24 @@
+"""Shared Databricks preset metadata helpers."""
+
+from __future__ import annotations
+
+from typing import Any
+
+Preset = dict[str, Any]
+PRESET_META_KEY = "_preset"
+
+
+def meta(
+    name: str,
+    category: str,
+    kind: str,
+    description: str,
+    required_fields: list[str] | None = None,
+) -> dict[str, Any]:
+    return {
+        "name": name,
+        "description": description,
+        "category": category,
+        "kind": kind,
+        "required_fields": list(required_fields or []),
+    }

contractforge_databricks/presets/bronze.py

@@ -0,0 +1,57 @@
+"""Bronze Databricks presets ported from ContractForge."""
+
+from __future__ import annotations
+
+from contractforge_databricks.presets.base import PRESET_META_KEY, Preset, meta
+
+BRONZE_PRESETS: dict[str, Preset] = {
+    "bronze_file_append": {
+        PRESET_META_KEY: meta("bronze_file_append", "bronze", "ingestion", "Bronze append for batch files."),
+        "layer": "bronze",
+        "mode": "scd0_append",
+        "schema_policy": "additive_only",
+        "on_quality_fail": "fail",
+    },
+    "bronze_table_append": {
+        PRESET_META_KEY: meta("bronze_table_append", "bronze", "ingestion", "Bronze append for table replication."),
+        "layer": "bronze",
+        "mode": "scd0_append",
+        "schema_policy": "additive_only",
+        "on_quality_fail": "fail",
+    },
+    "bronze_autoloader_append": {
+        PRESET_META_KEY: meta(
+            "bronze_autoloader_append",
+            "bronze",
+            "ingestion",
+            "Bronze available-now Auto Loader append.",
+            ["source.path", "source.progress_location", "source.schema_tracking_location", "target_table"],
+        ),
+        "source": {"type": "incremental_files", "trigger": "available_now", "format": "parquet"},
+        "layer": "bronze",
+        "mode": "scd0_append",
+        "schema_policy": "additive_only",
+        "on_quality_fail": "fail",
+        "idempotency_policy": "skip_if_success",
+    },
+    "bronze_full_overwrite": {
+        PRESET_META_KEY: meta("bronze_full_overwrite", "bronze", "ingestion", "Bronze full snapshot overwrite."),
+        "layer": "bronze",
+        "mode": "scd0_overwrite",
+        "schema_policy": "additive_only",
+        "on_quality_fail": "fail",
+    },
+    "bronze_partition_overwrite": {
+        PRESET_META_KEY: meta(
+            "bronze_partition_overwrite",
+            "bronze",
+            "ingestion",
+            "Bronze overwrite for one controlled partition.",
+            ["extensions.databricks.partition_column", "extensions.databricks.partition_value"],
+        ),
+        "layer": "bronze",
+        "mode": "scd0_overwrite",
+        "schema_policy": "additive_only",
+        "on_quality_fail": "fail",
+    },
+}

contractforge_databricks/presets/catalog.py

@@ -0,0 +1,22 @@
+"""Databricks-owned preset catalog ported from ContractForge."""
+
+from __future__ import annotations
+
+from contractforge_databricks.presets.base import PRESET_META_KEY as PRESET_META_KEY, Preset
+from contractforge_databricks.presets.bronze import BRONZE_PRESETS
+from contractforge_databricks.presets.gold import GOLD_PRESETS
+from contractforge_databricks.presets.modifiers import DELTA_PRESETS, GOVERNANCE_PRESETS, QUALITY_PRESETS
+from contractforge_databricks.presets.runtime import RUNTIME_PRESETS
+from contractforge_databricks.presets.silver import SILVER_PRESETS
+from contractforge_databricks.presets.write_engine import WRITE_ENGINE_PRESETS
+
+BUILTIN_PRESETS: dict[str, Preset] = {
+    **BRONZE_PRESETS,
+    **SILVER_PRESETS,
+    **GOLD_PRESETS,
+    **QUALITY_PRESETS,
+    **DELTA_PRESETS,
+    **GOVERNANCE_PRESETS,
+    **RUNTIME_PRESETS,
+    **WRITE_ENGINE_PRESETS,
+}

contractforge_databricks/presets/core.py

@@ -0,0 +1,134 @@
+"""Preset helpers for Databricks adapter examples and templates."""
+
+from __future__ import annotations
+
+from copy import deepcopy
+from typing import Any
+
+from contractforge_databricks.presets.catalog import BUILTIN_PRESETS, PRESET_META_KEY, Preset
+
+PRESETS: dict[str, Preset] = deepcopy(BUILTIN_PRESETS)
+
+
+def list_presets() -> list[str]:
+    return sorted(PRESETS)
+
+
+def get_preset(name: str) -> Preset:
+    if name not in PRESETS:
+        raise ValueError(f"Preset not found: {name}. valid presets: {list_presets()}")
+    return deepcopy(PRESETS[name])
+
+
+def register_preset(name: str, preset: Preset, *, override: bool = False) -> None:
+    normalized_name = str(name or "").strip()
+    if not normalized_name:
+        raise ValueError("preset name cannot be empty")
+    if not isinstance(preset, dict):
+        raise ValueError("preset must be a dict")
+    if normalized_name in PRESETS and not override:
+        raise ValueError(f"Preset already registered: {normalized_name}")
+    payload = deepcopy(preset)
+    meta = dict(payload.get(PRESET_META_KEY) or {})
+    meta.setdefault("name", normalized_name)
+    meta.setdefault("description", "")
+    meta.setdefault("category", "custom")
+    meta.setdefault("kind", "modifier")
+    meta.setdefault("required_fields", [])
+    payload[PRESET_META_KEY] = meta
+    PRESETS[normalized_name] = payload
+
+
+def preset_details(name: str) -> dict[str, Any]:
+    preset = get_preset(name)
+    meta = dict(preset.pop(PRESET_META_KEY, {}))
+    return {
+        "name": name,
+        "description": meta.get("description", ""),
+        "category": meta.get("category", "custom"),
+        "kind": meta.get("kind", "modifier"),
+        "required_fields": list(meta.get("required_fields") or []),
+        "sets": sorted(_flatten_keys(preset)),
+    }
+
+
+def apply_preset(contract: dict[str, Any]) -> dict[str, Any]:
+    names = _preset_names(contract)
+    expanded: dict[str, Any] = {}
+    metas = []
+    for name in names:
+        preset = get_preset(name)
+        metas.append(dict(preset.pop(PRESET_META_KEY, {})))
+        expanded = _deep_merge(expanded, preset)
+    explicit = _copy(contract)
+    explicit.pop("preset", None)
+    explicit.pop("presets", None)
+    expanded = _deep_merge(expanded, explicit)
+    expanded["applied_presets"] = names
+    _validate_exclusive(metas)
+    _validate_required(expanded, metas)
+    return expanded
+
+
+def _preset_names(contract: dict[str, Any]) -> list[str]:
+    raw = contract.get("preset", contract.get("presets", []))
+    if raw is None:
+        return []
+    values = raw if isinstance(raw, list) else [raw]
+    names = [str(item).strip() for item in values]
+    if any(not name for name in names):
+        raise ValueError("preset cannot contain empty values")
+    return names
+
+
+def _deep_merge(base: dict[str, Any], override: dict[str, Any]) -> dict[str, Any]:
+    result = deepcopy(base)
+    for key, value in override.items():
+        if key in result and isinstance(result[key], dict) and isinstance(value, dict):
+            result[key] = _deep_merge(result[key], value)
+        else:
+            result[key] = _copy(value)
+    return result
+
+
+def _copy(value: Any) -> Any:
+    return deepcopy(value)
+
+
+def _validate_exclusive(metas: list[dict[str, Any]]) -> None:
+    kinds: dict[str, list[str]] = {}
+    for meta in metas:
+        kinds.setdefault(str(meta.get("kind") or "modifier"), []).append(str(meta.get("name") or "unknown"))
+    for kind in ("ingestion", "runtime"):
+        if len(kinds.get(kind, [])) > 1:
+            raise ValueError(f"Presets of kind {kind} are exclusive; received: {kinds[kind]}")
+
+
+def _validate_required(contract: dict[str, Any], metas: list[dict[str, Any]]) -> None:
+    missing = []
+    for meta in metas:
+        for field in meta.get("required_fields") or []:
+            if not _has_value(contract, str(field)):
+                missing.append(f"{meta.get('name')}:{field}")
+    if missing:
+        raise ValueError(f"Missing required fields for presets: {missing}")
+
+
+def _has_value(contract: dict[str, Any], field_path: str) -> bool:
+    current: Any = contract
+    for part in field_path.split("."):
+        if not isinstance(current, dict) or part not in current:
+            return False
+        current = current[part]
+    return current is not None and (not isinstance(current, (str, list, tuple, dict)) or bool(current))
+
+
+def _flatten_keys(payload: dict[str, Any], prefix: str = "") -> list[str]:
+    keys = []
+    for key, value in payload.items():
+        path = f"{prefix}.{key}" if prefix else str(key)
+        if isinstance(value, dict):
+            keys.extend(_flatten_keys(value, path))
+        else:
+            keys.append(path)
+    return keys

contractforge_databricks/presets/gold.py

@@ -0,0 +1,62 @@
+"""Gold Databricks presets ported from ContractForge."""
+
+from __future__ import annotations
+
+from contractforge_databricks.presets.base import PRESET_META_KEY, Preset, meta
+
+GOLD_PRESETS: dict[str, Preset] = {
+    "gold_full_refresh": {
+        PRESET_META_KEY: meta("gold_full_refresh", "gold", "ingestion", "Gold full refresh."),
+        "layer": "gold",
+        "mode": "scd0_overwrite",
+        "schema_policy": "strict",
+        "on_quality_fail": "fail",
+    },
+    "gold_partition_refresh": {
+        PRESET_META_KEY: meta(
+            "gold_partition_refresh",
+            "gold",
+            "ingestion",
+            "Gold recalculated by partition.",
+            ["extensions.databricks.partition_column", "extensions.databricks.partition_value"],
+        ),
+        "layer": "gold",
+        "mode": "scd0_overwrite",
+        "schema_policy": "strict",
+        "on_quality_fail": "fail",
+    },
+    "gold_replace_partitions": {
+        PRESET_META_KEY: meta(
+            "gold_replace_partitions",
+            "gold",
+            "ingestion",
+            "Gold declarative replacement of complete partitions.",
+            ["extensions.databricks.merge_partition_column"],
+        ),
+        "layer": "gold",
+        "mode": "scd1_upsert",
+        "extensions": {
+            "databricks": {
+                "merge_strategy": "replace_partitions",
+                "replace_partitions_source_complete": True,
+            }
+        },
+        "schema_policy": "strict",
+        "on_quality_fail": "fail",
+    },
+    "gold_snapshot_serving": {
+        PRESET_META_KEY: meta("gold_snapshot_serving", "gold", "ingestion", "Gold snapshot serving.", ["merge_keys"]),
+        "layer": "gold",
+        "mode": "snapshot_soft_delete",
+        "schema_policy": "strict",
+        "on_quality_fail": "fail",
+    },
+    "gold_scd1_serving": {
+        PRESET_META_KEY: meta("gold_scd1_serving", "gold", "ingestion", "Gold SCD1 serving.", ["merge_keys"]),
+        "layer": "gold",
+        "mode": "scd1_upsert",
+        "extensions": {"databricks": {"merge_strategy": "delta"}},
+        "schema_policy": "strict",
+        "on_quality_fail": "fail",
+    },
+}