sqlbuild 0.60.0__tar.gz → 0.62.0__tar.gz

{sqlbuild-0.60.0 → sqlbuild-0.62.0}/Cargo.lock

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

{sqlbuild-0.60.0 → sqlbuild-0.62.0}/PKG-INFO

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

{sqlbuild-0.60.0 → sqlbuild-0.62.0}/crates/sqlbuild-kata-native/Cargo.toml

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

{sqlbuild-0.60.0 → sqlbuild-0.62.0}/crates/sqlbuild-kata-native/src/configuration/_helpers/loading.rs

@@ -56,6 +56,7 @@ fn validate_raw(value: &toml::Value) -> Result<(), String> {
         "retired_source_tokens",
         "cte_name_whitelist",
         "cte_name_denylist",
+        "sql_tests",
         "cache",
     ];
     let mut unknown: Vec<String> = table
@@ -99,6 +100,27 @@ pub(crate) fn validate(config: &KataConfig) -> Result<(), String> {
         "min_tests_per_model",
         "min_custom_rule_test_cases",
     ];
+    let pipeline = Path::new(&config.sql_tests.pipeline_directory);
+    if config.sql_tests.pipeline_directory.trim().is_empty()
+        || config.sql_tests.pipeline_directory.contains('\\')
+        || config.sql_tests.pipeline_directory.contains("//")
+        || config.sql_tests.pipeline_directory.ends_with('/')
+        || config
+            .sql_tests
+            .pipeline_directory
+            .split('/')
+            .next()
+            .is_some_and(|component| component.ends_with(':'))
+        || pipeline.is_absolute()
+        || pipeline
+            .components()
+            .any(|component| !matches!(component, std::path::Component::Normal(_)))
+    {
+        return Err(
+            "kata.sql_tests.pipeline_directory must be a normalized path relative to tests/unit"
+                .into(),
+        );
+    }
     if let Some(name) = config
         .thresholds
         .keys()

{sqlbuild-0.60.0 → sqlbuild-0.62.0}/crates/sqlbuild-kata-native/src/constants.rs

@@ -1,6 +1,12 @@
 pub(crate) const API_VERSION: u32 = 1;
 pub(crate) const SCOPE_METADATA_SCHEMA_VERSION: u32 = 1;
 pub(crate) const BUILT_IN_RULE_NAMESPACE: &str = "SQBK";
+pub(crate) const PIPELINE_SUBJECT: &str = "pipeline";
+pub(crate) const GENERIC_TEST_NAME: &str = "test";
+pub(crate) const GENERIC_WORKS_NAME: &str = "works";
+pub(crate) const GENERIC_BASIC_NAME: &str = "basic";
+pub(crate) const GENERIC_SCENARIO_NAME: &str = "scenario";
+pub(crate) const GENERIC_CASE_NAME: &str = "case";
 pub(crate) const CUSTOM_RULE_NAMESPACE: &str = "XSQBK";
 pub(crate) const TARGET_DIRECTORY: &str = "target";
 pub(crate) const REFERENCE_KIND: &str = "ref";

{sqlbuild-0.60.0 → sqlbuild-0.62.0}/crates/sqlbuild-kata-native/src/engine/_helpers/evaluation.rs

@@ -3,9 +3,10 @@ use crate::constants::{API_VERSION, TARGET_DIRECTORY};
 use crate::engine::_helpers::cache::Cache;
 use crate::models::{EvaluateRequest, EvaluateResponse, Fault, RuleMetadata};
 use crate::rules::main::{
-    assemble_catalogue, evaluate as rules, fingerprint, resolve_threshold_overrides, select,
+    assemble_catalogue, evaluate as rules, evaluate_project, fingerprint,
+    resolve_threshold_overrides, select,
 };
-use crate::rules::models::ModelEvaluationRequest;
+use crate::rules::models::{ModelEvaluationRequest, ProjectEvaluationRequest};
 use fensu_policy::lifecycle::constants::ANALYSIS_BATCH_SCHEMA_VERSION;
 use fensu_policy::lifecycle::errors::LifecycleError;
 use fensu_policy::lifecycle::models::{
@@ -63,7 +64,7 @@ pub(crate) fn evaluate_json(request_json: &str) -> Result<String, String> {
         .any(|rule| rule.project_wide || rule.code.starts_with("SQBKX") || rule.custom);
     let project_fingerprint = if project_aware {
         Some(match &request.project_fingerprint {
-            Some(value) => value.clone(),
+            Some(value) => fingerprint_request_facts(value.as_bytes(), &request)?,
             None => fingerprint_project(Path::new(&request.project_dir), &request)?,
         })
     } else {
@@ -74,7 +75,10 @@ pub(crate) fn evaluate_json(request_json: &str) -> Result<String, String> {
         .transpose()?;
     let mut models: Vec<_> = request.models.iter().collect();
     models.sort_by(|left, right| left.relative_path.cmp(&right.relative_path));
-    let mut raw_faults: Vec<Fault> = Vec::new();
+    let mut raw_faults = evaluate_project::evaluate_project(ProjectEvaluationRequest {
+        selected: &selected_by_code,
+        request: &request,
+    })?;
     let mut cache_hits = 0;
     let mut cache_misses = 0;
     for (model_index, model) in models.iter().enumerate() {
@@ -159,9 +163,20 @@ fn fingerprint_project(project_dir: &Path, request: &EvaluateRequest) -> Result<
             )
         })?);
     }
+    fingerprint_request_facts(&digest.finalize(), request)
+}
+
+fn fingerprint_request_facts(seed: &[u8], request: &EvaluateRequest) -> Result<String, String> {
+    let mut digest = Sha256::new();
+    digest.update(seed);
     digest.update(
-        serde_json::to_vec(&(&request.public_enums, &request.public_constants))
-            .map_err(|error| error.to_string())?,
+        serde_json::to_vec(&(
+            &request.public_enums,
+            &request.public_constants,
+            &request.sql_tests,
+            &request.sql_scenarios,
+        ))
+        .map_err(|error| error.to_string())?,
     );
     Ok(format!("{:x}", digest.finalize()))
 }

{sqlbuild-0.60.0 → sqlbuild-0.62.0}/crates/sqlbuild-kata-native/src/engine/tests/helpers.rs

@@ -1,6 +1,8 @@
 use serde_json::{Value, json};
 use tempfile::TempDir;
 
+use crate::engine::main::evaluate::evaluate_json;
+
 pub(crate) fn request(project_dir: &TempDir, config: &Value) -> String {
     json!({
         "version": 1,
@@ -134,3 +136,71 @@ pub(crate) fn request_with_scope(scope: Value) -> Value {
         "scope_index": scope
     })
 }
+
+pub(crate) fn sql_test_policy_evaluation(
+    project_dir: &TempDir,
+    code: &str,
+    tests: Value,
+    scenarios: Value,
+    scope_index: Value,
+    extra_config: Value,
+) -> Result<Value, String> {
+    let mut config = json!({
+        "select": [code],
+        "cache": {"enabled": false}
+    });
+    config
+        .as_object_mut()
+        .expect("base policy config is an object")
+        .extend(
+            extra_config
+                .as_object()
+                .expect("extra policy config is an object")
+                .clone(),
+        );
+    let request = json!({
+        "version": 1,
+        "project_dir": project_dir.path(),
+        "config": config,
+        "models": [],
+        "sql_tests": tests,
+        "sql_scenarios": scenarios,
+        "scope_index": scope_index
+    });
+    serde_json::from_str(&evaluate_json(&request.to_string())?).map_err(|error| error.to_string())
+}
+
+pub(crate) fn sql_test_fact(path: &str, name: Option<&str>, targets: Value) -> Value {
+    json!({
+        "source_path": path,
+        "ownership_root": "tests/unit",
+        "block_index": 1,
+        "name": name.unwrap_or("test_orders"),
+        "explicit_name": name,
+        "mode": "model",
+        "expected_model_names": targets,
+        "assertion_names": [],
+        "assertion_target_model_names": [],
+        "target_model_names": targets,
+        "tested_resources": []
+    })
+}
+
+pub(crate) fn cached_sql_test_policy_request(project_dir: &TempDir, name: Option<&str>) -> String {
+    json!({
+        "version": 1,
+        "project_dir": project_dir.path(),
+        "project_fingerprint": "compiler-project-v1",
+        "config": {"select": ["SQBKT004"], "cache": {"enabled": true}},
+        "models": [{
+            "name": "orders", "relative_path": "models/orders.sql",
+            "query_sql": "SELECT 1", "authored_sql": "SELECT 1"
+        }],
+        "sql_tests": [sql_test_fact(
+            "tests/unit/test_orders__paid.sql", name, json!(["orders"])
+        )],
+        "sql_scenarios": [],
+        "scope_index": scope_index()
+    })
+    .to_string()
+}

sqlbuild-0.62.0/crates/sqlbuild-kata-native/src/engine/tests/test_sql_test_policy.rs

@@ -0,0 +1,261 @@
+use crate::engine::main::evaluate::evaluate_json;
+use crate::engine::tests::{helpers, test_types};
+use serde_json::{Value, json};
+use tempfile::TempDir;
+
+#[test]
+fn given_sql_test_facts_when_evaluating_project_policy_then_returns_expected_faults()
+-> Result<(), String> {
+    let project_dir = TempDir::new().map_err(|error| error.to_string())?;
+    let mut misplaced_test = helpers::sql_test_fact(
+        "quality/test_orders__paid.sql",
+        Some("orders: keeps paid orders"),
+        json!([]),
+    );
+    misplaced_test["ownership_root"] = json!("quality");
+    let mut scope = helpers::scope_index();
+    scope["resources"] = json!([
+        {
+            "identity": "model:stg_orders", "kind": "model", "name": "stg_orders",
+            "path": "models/commerce/staging/stg_orders.sql", "ownership_root": "models",
+            "ownership_root_kind": "model"
+        },
+        {
+            "identity": "model:fact_orders", "kind": "model", "name": "fact_orders",
+            "path": "models/commerce/marts/fact_orders.sql", "ownership_root": "models",
+            "ownership_root_kind": "model"
+        },
+        {
+            "identity": "model:daily_revenue", "kind": "model", "name": "daily_revenue",
+            "path": "models/finance/marts/daily_revenue.sql", "ownership_root": "models",
+            "ownership_root_kind": "model"
+        }
+    ]);
+    let mut macro_test = helpers::sql_test_fact(
+        "tests/unit/macros/test_normalize__trims.sql",
+        Some("normalize: trims spaces"),
+        json!([]),
+    );
+    macro_test["mode"] = json!("macro");
+    macro_test["tested_resources"] = json!([{"kind": "macro", "name": "normalize_status"}]);
+    let test_cases = [
+        test_types::SqlTestPolicyTestCase {
+            description: "canonical roots run without a model anchor",
+            code: "SQBKT001",
+            tests: json!([misplaced_test]),
+            scenarios: json!([{
+                "source_path": "quality/orders__paid.sql", "ownership_root": "quality",
+                "name": "orders__paid", "description": "Paid orders remain visible",
+                "expected_model_names": [], "assertion_names": [],
+                "assertion_target_model_names": [], "target_model_names": []
+            }]),
+            scope_index: helpers::scope_index(),
+            config: json!({}),
+            expected_fault_count: 2,
+            expected_evaluated_models: 0,
+            expected_paths: &["quality/orders__paid.sql", "quality/test_orders__paid.sql"],
+        },
+        test_types::SqlTestPolicyTestCase {
+            description: "filename grammar checks unit and scenario paths",
+            code: "SQBKT002",
+            tests: json!([
+                helpers::sql_test_fact(
+                    "tests/unit/test_orders__keeps_paid.sql",
+                    Some("orders: keeps paid orders"),
+                    json!([])
+                ),
+                helpers::sql_test_fact(
+                    "tests/unit/orders.sql",
+                    Some("orders: excludes cancelled orders"),
+                    json!([])
+                )
+            ]),
+            scenarios: json!([{
+                "source_path": "tests/scenarios/daily_revenue.sql",
+                "ownership_root": "tests/scenarios", "name": "daily_revenue",
+                "description": "Daily revenue includes successful payments",
+                "expected_model_names": [], "assertion_names": [],
+                "assertion_target_model_names": [], "target_model_names": []
+            }]),
+            scope_index: helpers::scope_index(),
+            config: json!({}),
+            expected_fault_count: 2,
+            expected_evaluated_models: 0,
+            expected_paths: &["tests/scenarios/daily_revenue.sql", "tests/unit/orders.sql"],
+        },
+        test_types::SqlTestPolicyTestCase {
+            description: "resolved ownership uses LCA, pipeline, and direct resource paths",
+            code: "SQBKT003",
+            tests: json!([
+                helpers::sql_test_fact(
+                    "tests/unit/commerce/staging/test_stg_orders__paid.sql",
+                    Some("stg_orders: keeps paid orders"),
+                    json!(["stg_orders"])
+                ),
+                helpers::sql_test_fact(
+                    "tests/unit/commerce/test_order_pipeline__paid.sql",
+                    Some("commerce: keeps paid orders"),
+                    json!(["stg_orders", "fact_orders"])
+                ),
+                helpers::sql_test_fact(
+                    "tests/unit/wrong/test_pipeline__revenue.sql",
+                    Some("pipeline: calculates revenue"),
+                    json!(["stg_orders", "daily_revenue"])
+                ),
+                macro_test
+            ]),
+            scenarios: json!([]),
+            scope_index: scope,
+            config: json!({"sql_tests": {"pipeline_directory": "chains"}}),
+            expected_fault_count: 1,
+            expected_evaluated_models: 0,
+            expected_paths: &["tests/unit/wrong/test_pipeline__revenue.sql"],
+        },
+        test_types::SqlTestPolicyTestCase {
+            description: "structured names require explicit target-aware behavior",
+            code: "SQBKT004",
+            tests: json!([
+                helpers::sql_test_fact(
+                    "tests/unit/test_orders__paid.sql",
+                    Some("orders: keeps paid orders: after capture"),
+                    json!(["orders"])
+                ),
+                helpers::sql_test_fact(
+                    "tests/unit/test_orders__basic.sql",
+                    Some("orders: basic"),
+                    json!(["orders"])
+                ),
+                helpers::sql_test_fact("tests/unit/test_orders__paid.sql", None, json!(["orders"])),
+                helpers::sql_test_fact(
+                    "tests/unit/test_orders__paid.sql",
+                    Some("payments: keeps paid orders"),
+                    json!(["orders"])
+                )
+            ]),
+            scenarios: json!([]),
+            scope_index: helpers::scope_index(),
+            config: json!({}),
+            expected_fault_count: 3,
+            expected_evaluated_models: 0,
+            expected_paths: &[
+                "tests/unit/test_orders__basic.sql",
+                "tests/unit/test_orders__paid.sql",
+                "tests/unit/test_orders__paid.sql",
+            ],
+        },
+        test_types::SqlTestPolicyTestCase {
+            description: "scenario descriptions reject generic numbering",
+            code: "SQBKT101",
+            tests: json!([]),
+            scenarios: json!([
+                {
+                    "source_path": "tests/scenarios/orders__paid.sql",
+                    "ownership_root": "tests/scenarios", "name": "orders__paid",
+                    "description": "Paid orders remain visible", "expected_model_names": [],
+                    "assertion_names": [], "assertion_target_model_names": [],
+                    "target_model_names": []
+                },
+                {
+                    "source_path": "tests/scenarios/orders__case_1.sql",
+                    "ownership_root": "tests/scenarios", "name": "orders__case_1",
+                    "description": "case 1", "expected_model_names": [],
+                    "assertion_names": [], "assertion_target_model_names": [],
+                    "target_model_names": []
+                }
+            ]),
+            scope_index: helpers::scope_index(),
+            config: json!({}),
+            expected_fault_count: 1,
+            expected_evaluated_models: 0,
+            expected_paths: &["tests/scenarios/orders__case_1.sql"],
+        },
+        test_types::SqlTestPolicyTestCase {
+            description: "path-scoped ignore suppresses a test policy fault",
+            code: "SQBKT004",
+            tests: json!([helpers::sql_test_fact(
+                "tests/unit/test_orders__paid.sql",
+                None,
+                json!(["orders"])
+            )]),
+            scenarios: json!([]),
+            scope_index: helpers::scope_index(),
+            config: json!({"rule_ignores": [{
+                "rules": ["SQBKT004"], "paths": ["tests/unit/**"],
+                "reason": "tracked naming migration"
+            }]}),
+            expected_fault_count: 0,
+            expected_evaluated_models: 0,
+            expected_paths: &[],
+        },
+    ];
+
+    for test_case in test_cases {
+        let result = helpers::sql_test_policy_evaluation(
+            &project_dir,
+            test_case.code,
+            test_case.tests,
+            test_case.scenarios,
+            test_case.scope_index,
+            test_case.config,
+        )?;
+        let paths: Vec<&str> = result["faults"]
+            .as_array()
+            .into_iter()
+            .flatten()
+            .filter_map(|fault| fault["path"].as_str())
+            .collect();
+        assert_eq!(
+            result["faults"].as_array().map(Vec::len),
+            Some(test_case.expected_fault_count),
+            "{}",
+            test_case.description
+        );
+        assert_eq!(
+            result["evaluated_models"], test_case.expected_evaluated_models,
+            "{}",
+            test_case.description
+        );
+        assert_eq!(paths, test_case.expected_paths, "{}", test_case.description);
+    }
+    Ok(())
+}
+
+#[test]
+fn given_test_fact_change_when_evaluating_cached_project_rule_then_model_cache_is_invalidated()
+-> Result<(), String> {
+    let project_dir = TempDir::new().map_err(|error| error.to_string())?;
+    let test_cases = [test_types::SqlTestPolicyCacheTestCase {
+        description: "test fact change invalidates model cache identity",
+        expected_first_misses: 1,
+        expected_second_hits: 0,
+        expected_second_misses: 1,
+    }];
+    for test_case in &test_cases {
+        let first: Value = serde_json::from_str(&evaluate_json(
+            &helpers::cached_sql_test_policy_request(&project_dir, None),
+        )?)
+        .map_err(|error| error.to_string())?;
+        let second: Value =
+            serde_json::from_str(&evaluate_json(&helpers::cached_sql_test_policy_request(
+                &project_dir,
+                Some("orders: keeps paid orders"),
+            ))?)
+            .map_err(|error| error.to_string())?;
+        assert_eq!(
+            first["cache_misses"], test_case.expected_first_misses,
+            "{}",
+            test_case.description
+        );
+        assert_eq!(
+            second["cache_hits"], test_case.expected_second_hits,
+            "{}",
+            test_case.description
+        );
+        assert_eq!(
+            second["cache_misses"], test_case.expected_second_misses,
+            "{}",
+            test_case.description
+        );
+    }
+    Ok(())
+}

{sqlbuild-0.60.0 → sqlbuild-0.62.0}/crates/sqlbuild-kata-native/src/engine/tests/test_types.rs

@@ -41,3 +41,22 @@ pub(crate) struct MissingScopeFactsTestCase {
     pub(crate) expected_complete: bool,
     pub(crate) expected_runtime_usage: bool,
 }
+
+pub(crate) struct SqlTestPolicyTestCase {
+    pub(crate) description: &'static str,
+    pub(crate) code: &'static str,
+    pub(crate) tests: Value,
+    pub(crate) scenarios: Value,
+    pub(crate) scope_index: Value,
+    pub(crate) config: Value,
+    pub(crate) expected_fault_count: usize,
+    pub(crate) expected_evaluated_models: usize,
+    pub(crate) expected_paths: &'static [&'static str],
+}
+
+pub(crate) struct SqlTestPolicyCacheTestCase {
+    pub(crate) description: &'static str,
+    pub(crate) expected_first_misses: u64,
+    pub(crate) expected_second_hits: u64,
+    pub(crate) expected_second_misses: u64,
+}

{sqlbuild-0.60.0 → sqlbuild-0.62.0}/crates/sqlbuild-kata-native/src/engine/tests.rs

@@ -4,5 +4,7 @@ mod evaluation;
 mod helpers;
 #[path = "tests/test_scope_facts.rs"]
 mod scope_facts;
+#[path = "tests/test_sql_test_policy.rs"]
+mod sql_test_policy;
 #[path = "tests/test_types.rs"]
 mod test_types;

{sqlbuild-0.60.0 → sqlbuild-0.62.0}/crates/sqlbuild-kata-native/src/models.rs

@@ -51,6 +51,20 @@ pub(crate) struct ThresholdOverride {
     pub reason: String,
 }
 
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[serde(default, deny_unknown_fields)]
+pub(crate) struct SqlTestPolicyConfig {
+    pub pipeline_directory: String,
+}
+
+impl Default for SqlTestPolicyConfig {
+    fn default() -> Self {
+        Self {
+            pipeline_directory: "pipelines".into(),
+        }
+    }
+}
+
 #[derive(Clone, Debug, Deserialize, Serialize)]
 #[serde(default, deny_unknown_fields)]
 pub(crate) struct KataConfig {
@@ -69,6 +83,7 @@ pub(crate) struct KataConfig {
     pub retired_source_tokens: BTreeMap<String, String>,
     pub cte_name_whitelist: Vec<String>,
     pub cte_name_denylist: Vec<String>,
+    pub sql_tests: SqlTestPolicyConfig,
     pub cache: CacheConfig,
 }
 
@@ -90,6 +105,7 @@ impl Default for KataConfig {
             retired_source_tokens: BTreeMap::new(),
             cte_name_whitelist: vec![],
             cte_name_denylist: vec![],
+            sql_tests: SqlTestPolicyConfig::default(),
             cache: CacheConfig::enabled_by_default(),
         }
     }
@@ -421,6 +437,89 @@ pub(crate) struct Model {
     pub targeting_test_count: u32,
 }
 
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[serde(rename_all = "snake_case")]
+pub(crate) enum SqlTestMode {
+    Model,
+    Macro,
+    Udf,
+    TableFn,
+}
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[serde(rename_all = "snake_case")]
+pub(crate) enum DirectTestResourceKind {
+    Macro,
+    Udf,
+    TableFn,
+}
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[serde(deny_unknown_fields)]
+pub(crate) struct TestedResource {
+    pub kind: DirectTestResourceKind,
+    pub name: String,
+}
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[serde(deny_unknown_fields)]
+pub(crate) struct SqlTestParameterFact {
+    pub name: String,
+    #[serde(rename = "type")]
+    pub value_type: String,
+    pub nullable: bool,
+}
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[serde(deny_unknown_fields)]
+pub(crate) struct SqlTestParameterValueFact {
+    pub name: String,
+    #[serde(rename = "type")]
+    pub value_type: String,
+    pub value: serde_json::Value,
+}
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[serde(deny_unknown_fields)]
+pub(crate) struct SqlTestFact {
+    pub source_path: String,
+    pub ownership_root: String,
+    pub block_index: u64,
+    pub name: String,
+    pub explicit_name: Option<String>,
+    #[serde(default)]
+    pub parent_name: Option<String>,
+    #[serde(default)]
+    pub case_name: Option<String>,
+    #[serde(default)]
+    pub case_index: Option<u64>,
+    #[serde(default)]
+    pub case_fingerprint: Option<String>,
+    #[serde(default)]
+    pub parameter_schema: Vec<SqlTestParameterFact>,
+    #[serde(default)]
+    pub parameters: Vec<SqlTestParameterValueFact>,
+    pub mode: SqlTestMode,
+    pub expected_model_names: Vec<String>,
+    pub assertion_names: Vec<String>,
+    pub assertion_target_model_names: Vec<String>,
+    pub target_model_names: Vec<String>,
+    pub tested_resources: Vec<TestedResource>,
+}
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[serde(deny_unknown_fields)]
+pub(crate) struct SqlScenarioFact {
+    pub source_path: String,
+    pub ownership_root: String,
+    pub name: String,
+    pub description: Option<String>,
+    pub expected_model_names: Vec<String>,
+    pub assertion_names: Vec<String>,
+    pub assertion_target_model_names: Vec<String>,
+    pub target_model_names: Vec<String>,
+}
+
 #[derive(Clone, Debug, Deserialize, Serialize)]
 #[serde(deny_unknown_fields)]
 pub(crate) struct CustomRule {
@@ -466,6 +565,8 @@ pub(crate) struct EvaluateRequest {
     pub project_dir: String,
     pub config: KataConfig,
     pub models: Vec<Model>,
+    pub sql_tests: Vec<SqlTestFact>,
+    pub sql_scenarios: Vec<SqlScenarioFact>,
     pub public_enums: Vec<Declaration>,
     pub public_constants: Vec<Declaration>,
     pub scope_index: ScopeIndexFacts,
@@ -499,6 +600,8 @@ impl Default for EvaluateRequest {
             project_dir: ".".into(),
             config: KataConfig::default(),
             models: vec![],
+            sql_tests: vec![],
+            sql_scenarios: vec![],
             public_enums: vec![],
             public_constants: vec![],
             scope_index: ScopeIndexFacts::default(),