safe_migrate/rules/
functions.rs

1use crate::analysis::mutations::Mutation;
2use crate::analysis::state::{AnalysisState, CascadeResult, MutationResult, PreState};
3use crate::engine::config::Config;
4use crate::report::violations::{ObjectKind, OperationKind, Violation, ViolationTier};
5use crate::rules::Rule;
6
7pub struct FunctionVolatilityRule;
8
9impl Rule for FunctionVolatilityRule {
10    fn id(&self) -> &'static str {
11        "function-volatility-change"
12    }
13    fn default_tier(&self) -> ViolationTier {
14        ViolationTier::Tier2
15    }
16    fn recipe(&self) -> &'static str {
17        "Changing a function's volatility (e.g., IMMUTABLE -> VOLATILE) can invalidate existing indexes or change query plan stability."
18    }
19
20    fn evaluate(
21        &self,
22        mutation: &Mutation,
23        _result: &MutationResult,
24        pre_state: &PreState,
25        _state: &AnalysisState,
26        _config: &Config,
27        _cascade: Option<&CascadeResult>,
28    ) -> Vec<Violation> {
29        let mut violations = Vec::new();
30
31        if let Mutation::AlterFunction(alter) = mutation
32            && let Some(old_func) = pre_state.functions.get(&alter.id)
33            && let crate::analysis::facts::AlterFunctionAction::OptionsChange(new_opts) =
34                &alter.action
35            && let Some(nv) = new_opts.iter().find_map(|opt| {
36                if let crate::analysis::facts::FuncOptionFact::Volatility(v) = opt {
37                    match v {
38                        crate::analysis::facts::VolatilityKind::Volatile => {
39                            Some(crate::model::function::Volatility::Volatile)
40                        }
41                        crate::analysis::facts::VolatilityKind::Stable => {
42                            Some(crate::model::function::Volatility::Stable)
43                        }
44                        crate::analysis::facts::VolatilityKind::Immutable => {
45                            Some(crate::model::function::Volatility::Immutable)
46                        }
47                    }
48                } else {
49                    None
50                }
51            })
52        {
53            let ov = old_func.volatility.clone();
54            if ov != nv {
55                violations.push(Violation {
56                    source_range: None,
57                    rule_id: self.id(),
58                    operation_kind: OperationKind::AlterFunction,
59                    object_kind: ObjectKind::Function,
60                    object_name: alter.id.to_string(),
61                    tier: self.default_tier(),
62                    reason: format!(
63                        "Function {} volatility changed from {:?} to {:?}",
64                        alter.id, ov, nv
65                    ),
66                    recipe: self.recipe(),
67                    dedup_key: None,
68                    sql: None,
69                    fk_dependency_related: false,
70                });
71            }
72        }
73
74        violations
75    }
76}
77
78pub struct BrokenComputeRule;
79
80impl Rule for BrokenComputeRule {
81    fn id(&self) -> &'static str {
82        "broken-compute"
83    }
84    fn default_tier(&self) -> ViolationTier {
85        ViolationTier::Tier1
86    }
87    fn recipe(&self) -> &'static str {
88        "Dropping a function used by a trigger will cause the trigger to fail at runtime."
89    }
90
91    fn evaluate(
92        &self,
93        mutation: &Mutation,
94        result: &MutationResult,
95        _pre_state: &PreState,
96        state: &AnalysisState,
97        _config: &Config,
98        _cascade_closure: Option<&CascadeResult>,
99    ) -> Vec<Violation> {
100        if *result == MutationResult::Skipped {
101            return vec![];
102        }
103        if let Mutation::DropFunction(drop) = mutation {
104            for sig in &drop.signatures {
105                // Construct ID in same way as during creation
106                let sig_str = format!("{}({})", sig.name.name.resolve(), sig.params.join(","));
107                let schema = state.resolve_function_schema(&sig.name, &sig_str);
108                let function_id = crate::ast::identifiers::ObjectId::new(schema, sig_str);
109
110                let affected = state.local.graph.triggers_for_function(&function_id);
111
112                if !affected.is_empty() {
113                    let triggers_info: Vec<String> = affected
114                        .iter()
115                        .map(|t| format!("trigger {} on table {}", t.dependent, t.referenced))
116                        .collect();
117
118                    return vec![Violation {
119                        source_range: None,
120                        rule_id: self.id(),
121                        operation_kind: OperationKind::DropFunction,
122                        object_kind: ObjectKind::Function,
123                        object_name: function_id.to_string(),
124                        tier: self.default_tier(),
125                        reason: format!(
126                            "Broken Compute: Dropping Function Used by Trigger: {}",
127                            triggers_info.join(", ")
128                        ),
129                        recipe: self.recipe(),
130                        dedup_key: None,
131                        sql: None,
132                        fk_dependency_related: false,
133                    }];
134                }
135            }
136        }
137        vec![]
138    }
139}
safe_migrate/rules/functions.rs

safe_migrate/rules/
functions.rs
