vespertide_core/action/

mod.rs

mod data_migration;
mod display;
mod narrowing_strategy;
mod prefix;
mod remap_mapping_serde;

use crate::schema::{ColumnDef, ColumnName, ColumnType, TableConstraint, TableName};
pub use data_migration::{DataMigrationSql, leading_ddl_keyword, sql_preview};
pub use display::truncate_comment;
pub use narrowing_strategy::NarrowingStrategy;
use serde::{Deserialize, Serialize};
use std::collections::BTreeMap;

/// A single versioned migration, grouping a set of [`MigrationAction`]s under a version number.
///
/// Migration plans are auto-generated by `vespertide revision` and stored as JSON or YAML files
/// in the `migrations/` directory. **Never create or edit these files manually.**
///
/// The `version` field is a monotonically increasing integer. The `id` is a UUID that guards
/// against accidental plan substitution when the same version number appears in two different
/// migration histories.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
#[serde(rename_all = "snake_case")]
pub struct MigrationPlan {
    /// Unique identifier for this migration (UUID format).
    /// Defaults to empty string for backward compatibility with old migration files.
    #[serde(default)]
    pub id: String,
    /// Human-readable description of what this migration does (from `-m "message"`).
    pub comment: Option<String>,
    /// ISO 8601 timestamp of when the migration file was generated.
    #[serde(default)]
    pub created_at: Option<String>,
    /// Monotonically increasing version number, starting at 1.
    pub version: u32,
    /// Ordered list of schema changes to apply in this migration.
    pub actions: Vec<MigrationAction>,
}

/// A single schema change produced by the planner and consumed by the SQL generator.
///
/// The planner emits a `Vec<MigrationAction>` when diffing two schemas. The SQL generator
/// (`vespertide-query`) translates each action into backend-specific DDL statements.
///
/// Prefer typed actions over [`MigrationAction::RawSql`]. Raw SQL is an emergency escape hatch:
/// it is not portable across backends and is skipped during baseline replay, which means the
/// planner cannot reason about it. For SQL that only changes *data*, use
/// [`MigrationAction::DataMigration`] instead: it is skipped by replay too, but by contract
/// rather than by ignorance.
///
/// This enum is `#[non_exhaustive]`: new variants may be added in future releases.
/// Downstream `match` expressions should include a wildcard arm.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
#[serde(tag = "type", rename_all = "snake_case")]
#[non_exhaustive]
pub enum MigrationAction {
    /// Create a new table with the given columns and constraints (`CREATE TABLE`).
    CreateTable {
        table: TableName,
        columns: Vec<ColumnDef>,
        constraints: Vec<TableConstraint>,
    },
    /// Drop an existing table and all its data (`DROP TABLE`).
    DeleteTable { table: TableName },
    /// Add a new column to an existing table (`ALTER TABLE ... ADD COLUMN`).
    AddColumn {
        table: TableName,
        column: Box<ColumnDef>,
        /// Optional fill value to backfill existing rows when adding NOT NULL without default.
        fill_with: Option<String>,
    },
    /// Rename a column in an existing table (`ALTER TABLE ... RENAME COLUMN`).
    RenameColumn {
        table: TableName,
        from: ColumnName,
        to: ColumnName,
    },
    /// Remove a column from an existing table (`ALTER TABLE ... DROP COLUMN`).
    DeleteColumn {
        table: TableName,
        column: ColumnName,
    },
    /// Change the SQL type of an existing column (`ALTER TABLE ... ALTER COLUMN ... TYPE`).
    ModifyColumnType {
        table: TableName,
        column: ColumnName,
        new_type: ColumnType,
        /// Mapping of removed enum values to replacement values for safe enum value removal.
        /// Both sides are **bare** enum labels — write them exactly as they appear in the enum
        /// `values` list, with no surrounding SQL quotes. The SQL generator binds them as data
        /// values and adds the quoting itself.
        /// e.g., `{"cancelled": "pending"}` generates an `UPDATE` before the type change.
        /// A legacy pre-quoted replacement (`"'pending'"`) still works: one outer quote layer is
        /// stripped with a warning.
        #[serde(default, skip_serializing_if = "Option::is_none")]
        fill_with: Option<BTreeMap<String, String>>,
        /// Strategy for transforming existing rows that would violate a *narrowed* new type
        /// (smaller VARCHAR length, lower NUMERIC scale, smaller integer size, etc.) so the
        /// `ALTER COLUMN TYPE` cannot fail. When `None`, the SQL generator emits a plain ALTER —
        /// safe only when the user has independently verified no row violates the new type
        /// (typically prompted by the `vespertide revision` type-narrowing select UI).
        #[serde(default, skip_serializing_if = "Option::is_none")]
        narrowing_strategy: Option<NarrowingStrategy>,
        /// `IANA` timezone name (e.g. `"Asia/Seoul"`) or numeric UTC offset (e.g. `"+09:00"`)
        /// used when converting between `timestamp` and `timestamptz`. Required for safe
        /// migration on `PostgreSQL` where the conversion is non-trivial; ignored on `MySQL`
        /// and `SQLite` where vespertide maps both `timestamp` and `timestamptz` to the same
        /// underlying type. Validated by the CLI `revision` prompt against a 30-name
        /// whitelist plus numeric offset format `±HH:MM`.
        #[serde(default, skip_serializing_if = "Option::is_none")]
        timezone: Option<String>,
    },
    /// Change whether a column accepts `NULL` values.
    ModifyColumnNullable {
        table: TableName,
        column: ColumnName,
        nullable: bool,
        /// Required when changing from nullable to non-nullable to backfill existing NULL values.
        fill_with: Option<String>,
        /// When true, rows with NULL values in the column are deleted instead of backfilled.
        /// Mutually exclusive with `fill_with`. Useful for FK columns where a valid fill value
        /// may not exist.
        #[serde(default, skip_serializing_if = "Option::is_none")]
        delete_null_rows: Option<bool>,
    },
    /// Change or remove the default value of a column.
    ModifyColumnDefault {
        table: TableName,
        column: ColumnName,
        /// The new default value, or `None` to remove the default.
        new_default: Option<String>,
        /// **F15 fault gate — backfill existing rows.**
        ///
        /// `ALTER TABLE ... SET DEFAULT ...` only affects *new* rows. When
        /// the user wants every existing row updated to the new default in
        /// the same migration (the common "I want consistency right now"
        /// intent), the CLI's `revision` prompt captures that choice and
        /// stores the desired value here. The SQL generator then emits an
        /// `UPDATE table SET col = <value>` immediately after the ALTER.
        ///
        /// `None` (default, wire-format identical to v0.2.0) → skip the
        /// backfill: existing rows keep their current values. The action
        /// behaves exactly as before this field existed.
        #[serde(default, skip_serializing_if = "Option::is_none")]
        backfill: Option<String>,
    },
    /// Change or remove the comment on a column.
    ModifyColumnComment {
        table: TableName,
        column: ColumnName,
        /// The new comment, or `None` to remove the comment.
        new_comment: Option<String>,
    },
    /// Add a constraint (primary key, unique, foreign key, check, or index) to a table.
    ///
    /// F2 duplicate-handling strategy lives on the `Unique` variant of
    /// [`TableConstraint`] itself (see `TableConstraint::Unique.strategy`),
    /// not here — the strategy is intrinsic to a particular unique
    /// constraint, regardless of whether it is added, replaced, or shipped
    /// inside a `CreateTable`.
    AddConstraint {
        table: TableName,
        constraint: TableConstraint,
    },
    /// Remove a constraint from a table.
    RemoveConstraint {
        table: TableName,
        constraint: TableConstraint,
    },
    /// Atomically replace one constraint with another (e.g. when columns in a composite key change).
    ReplaceConstraint {
        table: TableName,
        from: TableConstraint,
        to: TableConstraint,
    },
    /// Remap stored integer values of an integer-backed enum column.
    ///
    /// Emitted when the user changes the `value` of an existing integer
    /// enum variant in the model (e.g. `medium: 5 → 10`). Because integer
    /// enums are stored as plain `INTEGER` in the database, the DB itself
    /// cannot detect the drift; if Vespertide stayed silent the ORM mapping
    /// would silently re-interpret existing rows. The SQL generator turns
    /// this action into a single atomic `UPDATE table SET col = CASE WHEN
    /// col = old THEN new ... END WHERE col IN (...)` that re-stamps every
    /// affected row before the new ORM mapping takes effect.
    ///
    /// `mapping` is a `BTreeMap<i64, i64>` keyed on the *old* value, so the
    /// type system guarantees a single replacement per source value.
    /// Canonical JSON wire format is `{"5": 10, "100": 20}` (string keys
    /// are how JSON represents map keys; serde transparently parses them
    /// back to `i64`). For backward compatibility the legacy array form
    /// `[[5, 10], [100, 20]]` is still accepted on read — see
    /// `remap_mapping_serde` for the details. The map iterates in
    /// `old_value` order at emit time so snapshots stay deterministic.
    /// Variants whose name AND value are unchanged are absent; variants
    /// added or removed (no name overlap on either side) are also absent
    /// — those need a separate migration action.
    RemapEnumValues {
        table: TableName,
        column: ColumnName,
        #[serde(with = "remap_mapping_serde")]
        #[cfg_attr(feature = "schema", schemars(with = "BTreeMap<String, i64>"))]
        mapping: BTreeMap<i64, i64>,
    },
    /// Rename a table (`ALTER TABLE ... RENAME TO`).
    RenameTable { from: TableName, to: TableName },
    /// Execute a raw SQL statement verbatim.
    ///
    /// **Emergency escape hatch only.** Raw SQL is not portable across backends and is invisible
    /// to baseline replay, so the planner cannot reason about schema state after this action.
    /// Use typed actions whenever possible.
    ///
    /// For SQL that changes **data only**, use [`MigrationAction::DataMigration`] instead. Both
    /// are skipped by baseline replay, but `raw_sql` is skipped because its effect is *unknown*
    /// while `data_migration` is skipped because *changing no schema* is its enforced contract.
    /// Using `raw_sql` for DDL silently drops that schema change from the reconstructed baseline,
    /// after which `vespertide diff` reports the same already-applied changes forever.
    RawSql { sql: String },
    /// Execute a **data-only** statement verbatim (`UPDATE` / `INSERT` / `DELETE` / …).
    ///
    /// This is the typed home for backfills that the schema-coupled facilities cannot express:
    /// conditional updates of *existing* columns, correlated-subquery backfills, and data
    /// reshaping during a format change. Unlike `AddColumn.fill_with` (which only fires for a
    /// newly added NOT NULL column with no default) or `ModifyColumnDefault.backfill` (one
    /// column, one value, every row), `data_migration` carries an arbitrary DML statement and
    /// is not tied to any schema change.
    ///
    /// **Contract: this action changes no schema.** Baseline replay skips it — not because its
    /// effect is unknown, as with [`MigrationAction::RawSql`], but because "no schema change"
    /// is guaranteed. The guarantee is enforced: a statement whose first token is `CREATE`,
    /// `ALTER`, `DROP`, or `TRUNCATE` is rejected at load and plan time.
    ///
    /// The SQL is emitted byte-for-byte as written — no case folding, cast rewriting, or
    /// reformatting. Set `sql` to a single string for portable SQL, or to an object keyed by
    /// `postgres` / `mysql` / `sqlite` when the statement cannot be portable. A `description`
    /// is optional but strongly encouraged: it is what `vespertide diff` shows for this action.
    DataMigration {
        /// The statement(s) to run, emitted verbatim. See [`DataMigrationSql`].
        sql: DataMigrationSql,
        /// Why this data change exists, shown in `vespertide diff` output.
        #[serde(default, skip_serializing_if = "Option::is_none")]
        description: Option<String>,
    },
}

impl MigrationAction {
    /// Returns the primary table this action affects, if any.
    /// Returns None for actions that don't bind to a single table
    /// (e.g. `RawSql`, `DataMigration`).
    #[must_use]
    pub fn table_name(&self) -> Option<&str> {
        match self {
            Self::CreateTable { table, .. }
            | Self::DeleteTable { table }
            | Self::AddColumn { table, .. }
            | Self::DeleteColumn { table, .. }
            | Self::RenameColumn { table, .. }
            | Self::ModifyColumnType { table, .. }
            | Self::ModifyColumnNullable { table, .. }
            | Self::ModifyColumnDefault { table, .. }
            | Self::ModifyColumnComment { table, .. }
            | Self::AddConstraint { table, .. }
            | Self::RemoveConstraint { table, .. }
            | Self::ReplaceConstraint { table, .. }
            | Self::RemapEnumValues { table, .. } => Some(table.as_str()),
            Self::RenameTable { from, .. } => Some(from.as_str()),
            Self::RawSql { .. } | Self::DataMigration { .. } => None,
        }
    }

    /// The DDL keyword this action's SQL illegally opens with, if any.
    ///
    /// Only [`MigrationAction::DataMigration`] carries a schema-neutrality
    /// contract, so every other variant returns `None`. Per-backend statements
    /// are all checked; the first offender wins.
    #[must_use]
    pub fn data_migration_ddl_violation(&self) -> Option<(&'static str, &str)> {
        let Self::DataMigration { sql, .. } = self else {
            return None;
        };
        sql.statements()
            .find_map(|stmt| leading_ddl_keyword(stmt).map(|keyword| (keyword, stmt)))
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::schema::{ReferenceAction, SimpleColumnType};
    use rstest::rstest;

    fn default_column() -> ColumnDef {
        ColumnDef::new("email", ColumnType::Simple(SimpleColumnType::Text), true)
    }

    fn idx(name: Option<&str>, cols: &[&str]) -> TableConstraint {
        TableConstraint::Index {
            name: name.map(Into::into),
            columns: cols.iter().map(|c| (*c).into()).collect(),
        }
    }
    fn pk_id() -> TableConstraint {
        TableConstraint::PrimaryKey {
            auto_increment: false,
            columns: vec!["id".into()],
            strategy: crate::PrimaryKeyAdditionStrategy::default(),
        }
    }
    fn pk_id_auto() -> TableConstraint {
        TableConstraint::PrimaryKey {
            auto_increment: true,
            columns: vec!["id".into()],
            strategy: crate::PrimaryKeyAdditionStrategy::default(),
        }
    }
    fn uq_email(name: Option<&str>) -> TableConstraint {
        TableConstraint::Unique {
            name: name.map(Into::into),
            columns: vec!["email".into()],
            strategy: crate::schema::UniqueConstraintStrategy::DeleteDuplicates {
                keep: crate::schema::KeepPolicy::First,
            },
        }
    }
    fn fk_user(name: Option<&str>, on_delete: Option<ReferenceAction>) -> TableConstraint {
        TableConstraint::ForeignKey {
            name: name.map(Into::into),
            columns: vec!["user_id".into()],
            ref_table: "users".into(),
            ref_columns: vec!["id".into()],
            on_delete,
            on_update: None,
            orphan_strategy: crate::ForeignKeyOrphanStrategy::default(),
        }
    }
    fn chk(name: &str, expr: &str) -> TableConstraint {
        TableConstraint::Check {
            name: name.into(),
            expr: expr.into(),
            strategy: crate::CheckViolationStrategy::default(),
        }
    }
    fn idx_email(name: Option<&str>) -> TableConstraint {
        idx(name, &["email"])
    }

    #[test]
    fn migration_action_wire_format_round_trip() {
        let canonical = r#"{"type":"create_table","table":"user","columns":[],"constraints":[]}"#;
        let parsed: MigrationAction = serde_json::from_str(canonical).expect("parse");
        let reserialized = serde_json::to_string(&parsed).expect("serialize");

        assert_eq!(
            reserialized, canonical,
            "wire format MUST be byte-identical"
        );
    }

    #[test]
    fn migration_action_rename_column_wire_format() {
        let canonical = r#"{"type":"rename_column","table":"orders","from":"old","to":"new"}"#;
        let parsed: MigrationAction = serde_json::from_str(canonical).expect("parse");
        let reserialized = serde_json::to_string(&parsed).expect("serialize");

        assert_eq!(reserialized, canonical);
    }

    #[test]
    fn migration_plan_real_example_round_trip() {
        let plan_json =
            include_str!("../../../../examples/app/migrations/0001_init.vespertide.json");
        let parsed: MigrationPlan =
            serde_json::from_str(plan_json).expect("real migration plan parses");
        let reserialized = serde_json::to_string(&parsed).expect("serialize");
        let reparsed: MigrationPlan = serde_json::from_str(&reserialized).expect("round-trip");

        assert_eq!(
            parsed, reparsed,
            "semantic content preserved across round-trip"
        );
    }

    #[rstest]
    #[case::create_table(
        MigrationAction::CreateTable {
            table: "users".into(),
            columns: vec![],
            constraints: vec![],
        },
        "CreateTable: users"
    )]
    #[case::delete_table(
        MigrationAction::DeleteTable {
            table: "users".into(),
        },
        "DeleteTable: users"
    )]
    #[case::add_column(
        MigrationAction::AddColumn {
            table: "users".into(),
            column: Box::new(default_column()),
            fill_with: None,
        },
        "AddColumn: users.email"
    )]
    #[case::rename_column(
        MigrationAction::RenameColumn {
            table: "users".into(),
            from: "old_name".into(),
            to: "new_name".into(),
        },
        "RenameColumn: users.old_name -> new_name"
    )]
    #[case::delete_column(
        MigrationAction::DeleteColumn {
            table: "users".into(),
            column: "email".into(),
        },
        "DeleteColumn: users.email"
    )]
    #[case::modify_column_type(
        MigrationAction::ModifyColumnType {
            table: "users".into(),
            column: "age".into(),
            new_type: ColumnType::Simple(SimpleColumnType::Integer),
            fill_with: None,
            narrowing_strategy: None,
            timezone: None,
        },
        "ModifyColumnType: users.age"
    )]
    #[case::add_constraint_index_with_name(
        MigrationAction::AddConstraint { table: "users".into(), constraint: idx_email(Some("ix_users__email")) },
        "AddConstraint: users.ix_users__email (INDEX)"
    )]
    #[case::add_constraint_index_without_name(
        MigrationAction::AddConstraint { table: "users".into(), constraint: idx_email(None) },
        "AddConstraint: users.INDEX"
    )]
    #[case::remove_constraint_index_with_name(
        MigrationAction::RemoveConstraint { table: "users".into(), constraint: idx_email(Some("ix_users__email")) },
        "RemoveConstraint: users.ix_users__email (INDEX)"
    )]
    #[case::remove_constraint_index_without_name(
        MigrationAction::RemoveConstraint { table: "users".into(), constraint: idx_email(None) },
        "RemoveConstraint: users.INDEX"
    )]
    #[case::rename_table(
        MigrationAction::RenameTable {
            from: "old_table".into(),
            to: "new_table".into(),
        },
        "RenameTable: old_table -> new_table"
    )]
    fn test_display_basic_actions(#[case] action: MigrationAction, #[case] expected: &str) {
        assert_eq!(action.to_string(), expected);
    }

    #[test]
    fn test_display_raw_sql_truncates_unicode_without_panicking() {
        let sql = "COMMENT ON COLUMN 한국어테이블.이름 IS '日本語 café 📊';".repeat(3);
        let action = MigrationAction::RawSql { sql };

        let display = action.to_string();

        assert!(display.starts_with("RawSql: COMMENT ON COLUMN 한국어테이블"));
        assert!(display.ends_with("..."));
    }

    #[rstest]
    #[case::create_table(
        MigrationAction::CreateTable {
            table: "users".into(),
            columns: vec![],
            constraints: vec![],
        },
        Some("users")
    )]
    #[case::rename_table(
        MigrationAction::RenameTable {
            from: "old_users".into(),
            to: "users".into(),
        },
        Some("old_users")
    )]
    #[case::raw_sql(MigrationAction::RawSql { sql: "SELECT 1".into() }, None)]
    #[case::data_migration(
        MigrationAction::DataMigration { sql: "UPDATE t SET x = 1".into(), description: None },
        None
    )]
    fn test_table_name(#[case] action: MigrationAction, #[case] expected: Option<&str>) {
        assert_eq!(action.table_name(), expected);
    }

    #[test]
    fn data_migration_wire_format_round_trip_without_description() {
        let canonical = r#"{"type":"data_migration","sql":"UPDATE user SET active = true"}"#;
        let parsed: MigrationAction = serde_json::from_str(canonical).expect("parse");
        assert_eq!(
            parsed,
            MigrationAction::DataMigration {
                sql: "UPDATE user SET active = true".into(),
                description: None,
            }
        );
        assert_eq!(
            serde_json::to_string(&parsed).expect("serialize"),
            canonical,
            "wire format MUST be byte-identical"
        );
    }

    #[test]
    fn data_migration_wire_format_round_trip_with_description() {
        let canonical = concat!(
            r#"{"type":"data_migration","sql":"UPDATE user SET active = true","#,
            r#""description":"activate legacy accounts"}"#
        );
        let parsed: MigrationAction = serde_json::from_str(canonical).expect("parse");
        assert_eq!(
            serde_json::to_string(&parsed).expect("serialize"),
            canonical
        );
    }

    #[test]
    fn data_migration_per_backend_wire_format_round_trip() {
        let canonical = concat!(
            r#"{"type":"data_migration","sql":{"postgres":"UPDATE a","#,
            r#""mysql":"UPDATE b","sqlite":"UPDATE c"}}"#
        );
        let parsed: MigrationAction = serde_json::from_str(canonical).expect("parse");
        assert_eq!(
            parsed,
            MigrationAction::DataMigration {
                sql: DataMigrationSql::PerBackend {
                    postgres: "UPDATE a".into(),
                    mysql: "UPDATE b".into(),
                    sqlite: "UPDATE c".into(),
                },
                description: None,
            }
        );
        assert_eq!(
            serde_json::to_string(&parsed).expect("serialize"),
            canonical
        );
    }

    #[rstest]
    #[case::uniform_dml("UPDATE user SET active = true".into(), None)]
    #[case::uniform_ddl("DROP TABLE user".into(), Some(("DROP", "DROP TABLE user")))]
    #[case::commented_ddl(
        "-- tidy up\n  truncate table audit".into(),
        Some(("TRUNCATE", "-- tidy up\n  truncate table audit"))
    )]
    fn data_migration_ddl_violation_detects_uniform_sql(
        #[case] sql: DataMigrationSql,
        #[case] expected: Option<(&'static str, &str)>,
    ) {
        let action = MigrationAction::DataMigration {
            sql,
            description: None,
        };
        assert_eq!(action.data_migration_ddl_violation(), expected);
    }

    #[test]
    fn data_migration_ddl_violation_scans_every_backend_statement() {
        let action = MigrationAction::DataMigration {
            sql: DataMigrationSql::PerBackend {
                postgres: "UPDATE t SET x = 1".into(),
                mysql: "UPDATE t SET x = 1".into(),
                sqlite: "ALTER TABLE t RENAME TO t2".into(),
            },
            description: None,
        };
        assert_eq!(
            action.data_migration_ddl_violation(),
            Some(("ALTER", "ALTER TABLE t RENAME TO t2")),
            "a DDL statement hidden in a non-default backend branch must still be caught"
        );
    }

    #[test]
    fn ddl_violation_is_none_for_every_non_data_migration_action() {
        let action = MigrationAction::RawSql {
            sql: "DROP TABLE user".to_string(),
        };
        assert_eq!(
            action.data_migration_ddl_violation(),
            None,
            "raw_sql keeps its escape-hatch freedom; only data_migration is constrained"
        );
    }

    #[rstest]
    #[case::with_description(
        MigrationAction::DataMigration {
            sql: "UPDATE user SET active = true".into(),
            description: Some("activate legacy accounts".into()),
        },
        "DataMigration: activate legacy accounts"
    )]
    #[case::without_description(
        MigrationAction::DataMigration {
            sql: "UPDATE user SET active = true".into(),
            description: None,
        },
        "DataMigration: UPDATE user SET active = true"
    )]
    #[case::per_backend_without_description(
        MigrationAction::DataMigration {
            sql: DataMigrationSql::PerBackend {
                postgres: "UPDATE pg".into(),
                mysql: "UPDATE my".into(),
                sqlite: "UPDATE lite".into(),
            },
            description: None,
        },
        "DataMigration: UPDATE pg"
    )]
    fn test_display_data_migration(#[case] action: MigrationAction, #[case] expected: &str) {
        assert_eq!(action.to_string(), expected);
    }

    #[rstest]
    #[case::add_constraint_primary_key(
        MigrationAction::AddConstraint { table: "users".into(), constraint: pk_id() },
        "AddConstraint: users.PRIMARY KEY"
    )]
    #[case::add_constraint_unique_with_name(
        MigrationAction::AddConstraint { table: "users".into(), constraint: uq_email(Some("uq_email")) },
        "AddConstraint: users.uq_email (UNIQUE)"
    )]
    #[case::add_constraint_unique_without_name(
        MigrationAction::AddConstraint { table: "users".into(), constraint: uq_email(None) },
        "AddConstraint: users.UNIQUE"
    )]
    #[case::add_constraint_foreign_key_with_name(
        MigrationAction::AddConstraint { table: "posts".into(), constraint: fk_user(Some("fk_user"), Some(ReferenceAction::Cascade)) },
        "AddConstraint: posts.fk_user (FOREIGN KEY)"
    )]
    #[case::add_constraint_foreign_key_without_name(
        MigrationAction::AddConstraint { table: "posts".into(), constraint: fk_user(None, None) },
        "AddConstraint: posts.FOREIGN KEY"
    )]
    #[case::add_constraint_check(
        MigrationAction::AddConstraint { table: "users".into(), constraint: chk("chk_age", "age > 0") },
        "AddConstraint: users.chk_age (CHECK)"
    )]
    fn test_display_add_constraint(#[case] action: MigrationAction, #[case] expected: &str) {
        assert_eq!(action.to_string(), expected);
    }

    #[rstest]
    #[case::remove_constraint_primary_key(
        MigrationAction::RemoveConstraint { table: "users".into(), constraint: pk_id() },
        "RemoveConstraint: users.PRIMARY KEY"
    )]
    #[case::remove_constraint_unique_with_name(
        MigrationAction::RemoveConstraint { table: "users".into(), constraint: uq_email(Some("uq_email")) },
        "RemoveConstraint: users.uq_email (UNIQUE)"
    )]
    #[case::remove_constraint_unique_without_name(
        MigrationAction::RemoveConstraint { table: "users".into(), constraint: uq_email(None) },
        "RemoveConstraint: users.UNIQUE"
    )]
    #[case::remove_constraint_foreign_key_with_name(
        MigrationAction::RemoveConstraint { table: "posts".into(), constraint: fk_user(Some("fk_user"), None) },
        "RemoveConstraint: posts.fk_user (FOREIGN KEY)"
    )]
    #[case::remove_constraint_foreign_key_without_name(
        MigrationAction::RemoveConstraint { table: "posts".into(), constraint: fk_user(None, None) },
        "RemoveConstraint: posts.FOREIGN KEY"
    )]
    #[case::remove_constraint_check(
        MigrationAction::RemoveConstraint { table: "users".into(), constraint: chk("chk_age", "age > 0") },
        "RemoveConstraint: users.chk_age (CHECK)"
    )]
    fn test_display_remove_constraint(#[case] action: MigrationAction, #[case] expected: &str) {
        assert_eq!(action.to_string(), expected);
    }

    #[rstest]
    #[case::raw_sql_short(
        MigrationAction::RawSql {
            sql: "SELECT 1".into(),
        },
        "RawSql: SELECT 1"
    )]
    fn test_display_raw_sql_short(#[case] action: MigrationAction, #[case] expected: &str) {
        assert_eq!(action.to_string(), expected);
    }

    #[test]
    fn test_display_raw_sql_long() {
        let action = MigrationAction::RawSql {
            sql:
                "SELECT * FROM users WHERE id = 1 AND name = 'test' AND email = 'test@example.com'"
                    .into(),
        };
        let result = action.to_string();
        assert!(result.starts_with("RawSql: "));
        assert!(result.ends_with("..."));
        assert!(result.len() > 10);
    }

    #[rstest]
    #[case::modify_column_nullable_to_not_null(
        MigrationAction::ModifyColumnNullable {
            table: "users".into(),
            column: "email".into(),
            nullable: false,
            fill_with: None,
            delete_null_rows: None,
        },
        "ModifyColumnNullable: users.email -> NOT NULL"
    )]
    #[case::modify_column_nullable_to_null(
        MigrationAction::ModifyColumnNullable {
            table: "users".into(),
            column: "email".into(),
            nullable: true,
            fill_with: None,
            delete_null_rows: None,
        },
        "ModifyColumnNullable: users.email -> NULL"
    )]
    fn test_display_modify_column_nullable(
        #[case] action: MigrationAction,
        #[case] expected: &str,
    ) {
        assert_eq!(action.to_string(), expected);
    }

    #[rstest]
    #[case::modify_column_default_set(
        MigrationAction::ModifyColumnDefault {
            table: "users".into(),
            column: "status".into(),
            new_default: Some("'active'".into()),
            backfill: None,
        },
        "ModifyColumnDefault: users.status -> 'active'"
    )]
    #[case::modify_column_default_drop(
        MigrationAction::ModifyColumnDefault {
            table: "users".into(),
            column: "status".into(),
            new_default: None,
            backfill: None,
        },
        "ModifyColumnDefault: users.status -> (none)"
    )]
    fn test_display_modify_column_default(#[case] action: MigrationAction, #[case] expected: &str) {
        assert_eq!(action.to_string(), expected);
    }

    #[rstest]
    #[case::modify_column_comment_set(
        MigrationAction::ModifyColumnComment {
            table: "users".into(),
            column: "email".into(),
            new_comment: Some("User email address".into()),
        },
        "ModifyColumnComment: users.email -> 'User email address'"
    )]
    #[case::modify_column_comment_drop(
        MigrationAction::ModifyColumnComment {
            table: "users".into(),
            column: "email".into(),
            new_comment: None,
        },
        "ModifyColumnComment: users.email -> (none)"
    )]
    fn test_display_modify_column_comment(#[case] action: MigrationAction, #[case] expected: &str) {
        assert_eq!(action.to_string(), expected);
    }

    #[test]
    fn test_display_modify_column_comment_long() {
        // Test truncation for long comments (> 30 chars)
        let action = MigrationAction::ModifyColumnComment {
            table: "users".into(),
            column: "email".into(),
            new_comment: Some(
                "This is a very long comment that should be truncated in display".into(),
            ),
        };
        let result = action.to_string();
        assert!(result.contains("..."));
        assert!(result.contains("This is a very long comment"));
        // Should be truncated at 27 chars + "..."
        assert!(!result.contains("truncated in display"));
    }

    // Tests for with_prefix
    #[test]
    fn test_action_with_prefix_create_table() {
        let action = MigrationAction::CreateTable {
            table: "users".into(),
            columns: vec![default_column()],
            constraints: vec![TableConstraint::ForeignKey {
                name: Some("fk_org".into()),
                columns: vec!["org_id".into()],
                ref_table: "organizations".into(),
                ref_columns: vec!["id".into()],
                on_delete: None,
                on_update: None,
                orphan_strategy: crate::ForeignKeyOrphanStrategy::default(),
            }],
        };
        let prefixed = action.with_prefix("myapp_");
        if let MigrationAction::CreateTable {
            table, constraints, ..
        } = prefixed
        {
            assert_eq!(table.as_str(), "myapp_users");
            if let TableConstraint::ForeignKey { ref_table, .. } = &constraints[0] {
                assert_eq!(ref_table.as_str(), "myapp_organizations");
            }
        } else {
            panic!("Expected CreateTable");
        }
    }

    #[test]
    fn test_action_with_prefix_delete_table() {
        let action = MigrationAction::DeleteTable {
            table: "users".into(),
        };
        let prefixed = action.with_prefix("myapp_");
        if let MigrationAction::DeleteTable { table } = prefixed {
            assert_eq!(table.as_str(), "myapp_users");
        } else {
            panic!("Expected DeleteTable");
        }
    }

    #[test]
    fn test_action_with_prefix_add_column() {
        let action = MigrationAction::AddColumn {
            table: "users".into(),
            column: Box::new(default_column()),
            fill_with: None,
        };
        let prefixed = action.with_prefix("myapp_");
        if let MigrationAction::AddColumn { table, .. } = prefixed {
            assert_eq!(table.as_str(), "myapp_users");
        } else {
            panic!("Expected AddColumn");
        }
    }

    #[test]
    fn test_action_with_prefix_rename_table() {
        let action = MigrationAction::RenameTable {
            from: "old_table".into(),
            to: "new_table".into(),
        };
        let prefixed = action.with_prefix("myapp_");
        if let MigrationAction::RenameTable { from, to } = prefixed {
            assert_eq!(from.as_str(), "myapp_old_table");
            assert_eq!(to.as_str(), "myapp_new_table");
        } else {
            panic!("Expected RenameTable");
        }
    }

    #[test]
    fn test_action_with_prefix_raw_sql_unchanged() {
        let action = MigrationAction::RawSql {
            sql: "SELECT * FROM users".into(),
        };
        let prefixed = action.with_prefix("myapp_");
        if let MigrationAction::RawSql { sql } = prefixed {
            // RawSql is not modified - user is responsible for table names
            assert_eq!(sql, "SELECT * FROM users");
        } else {
            panic!("Expected RawSql");
        }
    }

    #[test]
    fn test_action_with_prefix_empty_prefix() {
        let action = MigrationAction::CreateTable {
            table: "users".into(),
            columns: vec![],
            constraints: vec![],
        };
        let prefixed = action.clone().with_prefix("");
        if let MigrationAction::CreateTable { table, .. } = prefixed {
            assert_eq!(table.as_str(), "users");
        }
    }

    #[test]
    fn test_migration_plan_with_prefix() {
        let plan = MigrationPlan {
            id: String::new(),
            comment: Some("test".into()),
            created_at: None,
            version: 1,
            actions: vec![
                MigrationAction::CreateTable {
                    table: "users".into(),
                    columns: vec![],
                    constraints: vec![],
                },
                MigrationAction::CreateTable {
                    table: "posts".into(),
                    columns: vec![],
                    constraints: vec![fk_user(Some("fk_user"), None)],
                },
            ],
        };
        let prefixed = plan.with_prefix("myapp_");
        assert_eq!(prefixed.actions.len(), 2);

        if let MigrationAction::CreateTable { table, .. } = &prefixed.actions[0] {
            assert_eq!(table.as_str(), "myapp_users");
        }
        if let MigrationAction::CreateTable {
            table, constraints, ..
        } = &prefixed.actions[1]
        {
            assert_eq!(table.as_str(), "myapp_posts");
            if let TableConstraint::ForeignKey { ref_table, .. } = &constraints[0] {
                assert_eq!(ref_table.as_str(), "myapp_users");
            }
        }
    }

    #[test]
    fn test_action_with_prefix_rename_column() {
        let action = MigrationAction::RenameColumn {
            table: "users".into(),
            from: "name".into(),
            to: "full_name".into(),
        };
        let prefixed = action.with_prefix("myapp_");
        if let MigrationAction::RenameColumn { table, from, to } = prefixed {
            assert_eq!(table.as_str(), "myapp_users");
            assert_eq!(from.as_str(), "name");
            assert_eq!(to.as_str(), "full_name");
        } else {
            panic!("Expected RenameColumn");
        }
    }

    #[test]
    fn test_action_with_prefix_delete_column() {
        let action = MigrationAction::DeleteColumn {
            table: "users".into(),
            column: "old_field".into(),
        };
        let prefixed = action.with_prefix("myapp_");
        if let MigrationAction::DeleteColumn { table, column } = prefixed {
            assert_eq!(table.as_str(), "myapp_users");
            assert_eq!(column.as_str(), "old_field");
        } else {
            panic!("Expected DeleteColumn");
        }
    }

    #[test]
    fn test_action_with_prefix_modify_column_type() {
        let action = MigrationAction::ModifyColumnType {
            table: "users".into(),
            column: "age".into(),
            new_type: ColumnType::Simple(SimpleColumnType::BigInt),
            fill_with: None,
            narrowing_strategy: None,
            timezone: None,
        };
        let prefixed = action.with_prefix("myapp_");
        if let MigrationAction::ModifyColumnType {
            table,
            column,
            new_type,
            fill_with,
            ..
        } = prefixed
        {
            assert_eq!(table.as_str(), "myapp_users");
            assert_eq!(column.as_str(), "age");
            assert!(matches!(
                new_type,
                ColumnType::Simple(SimpleColumnType::BigInt)
            ));
            assert_eq!(fill_with, None);
        } else {
            panic!("Expected ModifyColumnType");
        }
    }

    #[test]
    fn test_action_with_prefix_modify_column_nullable() {
        let action = MigrationAction::ModifyColumnNullable {
            table: "users".into(),
            column: "email".into(),
            nullable: false,
            fill_with: Some("default@example.com".into()),
            delete_null_rows: None,
        };
        let prefixed = action.with_prefix("myapp_");
        if let MigrationAction::ModifyColumnNullable {
            table,
            column,
            nullable,
            fill_with,
            delete_null_rows,
        } = prefixed
        {
            assert_eq!(table.as_str(), "myapp_users");
            assert_eq!(column.as_str(), "email");
            assert!(!nullable);
            assert_eq!(fill_with, Some("default@example.com".into()));
            assert_eq!(delete_null_rows, None);
        } else {
            panic!("Expected ModifyColumnNullable");
        }
    }

    #[test]
    fn test_action_with_prefix_modify_column_default() {
        let action = MigrationAction::ModifyColumnDefault {
            table: "users".into(),
            column: "status".into(),
            new_default: Some("active".into()),
            backfill: None,
        };
        let prefixed = action.with_prefix("myapp_");
        if let MigrationAction::ModifyColumnDefault {
            table,
            column,
            new_default,
            ..
        } = prefixed
        {
            assert_eq!(table.as_str(), "myapp_users");
            assert_eq!(column.as_str(), "status");
            assert_eq!(new_default, Some("active".into()));
        } else {
            panic!("Expected ModifyColumnDefault");
        }
    }

    #[test]
    fn test_action_with_prefix_modify_column_comment() {
        let action = MigrationAction::ModifyColumnComment {
            table: "users".into(),
            column: "bio".into(),
            new_comment: Some("User biography".into()),
        };
        let prefixed = action.with_prefix("myapp_");
        if let MigrationAction::ModifyColumnComment {
            table,
            column,
            new_comment,
        } = prefixed
        {
            assert_eq!(table.as_str(), "myapp_users");
            assert_eq!(column.as_str(), "bio");
            assert_eq!(new_comment, Some("User biography".into()));
        } else {
            panic!("Expected ModifyColumnComment");
        }
    }

    #[test]
    fn test_action_with_prefix_add_constraint() {
        let action = MigrationAction::AddConstraint {
            table: "posts".into(),
            constraint: fk_user(Some("fk_user"), None),
        };
        let prefixed = action.with_prefix("myapp_");
        if let MigrationAction::AddConstraint { table, constraint } = prefixed {
            assert_eq!(table.as_str(), "myapp_posts");
            if let TableConstraint::ForeignKey { ref_table, .. } = constraint {
                assert_eq!(ref_table.as_str(), "myapp_users");
            } else {
                panic!("Expected ForeignKey constraint");
            }
        } else {
            panic!("Expected AddConstraint");
        }
    }

    #[test]
    fn test_action_with_prefix_remove_constraint() {
        let action = MigrationAction::RemoveConstraint {
            table: "posts".into(),
            constraint: fk_user(Some("fk_user"), None),
        };
        let prefixed = action.with_prefix("myapp_");
        if let MigrationAction::RemoveConstraint { table, constraint } = prefixed {
            assert_eq!(table.as_str(), "myapp_posts");
            if let TableConstraint::ForeignKey { ref_table, .. } = constraint {
                assert_eq!(ref_table.as_str(), "myapp_users");
            } else {
                panic!("Expected ForeignKey constraint");
            }
        } else {
            panic!("Expected RemoveConstraint");
        }
    }

    #[rstest]
    #[case::replace_constraint_primary_key(
        MigrationAction::ReplaceConstraint { table: "users".into(), from: pk_id(), to: pk_id_auto() },
        "ReplaceConstraint: users.PRIMARY KEY"
    )]
    #[case::replace_constraint_unique_with_name(
        MigrationAction::ReplaceConstraint { table: "users".into(), from: uq_email(None), to: uq_email(Some("uq_email")) },
        "ReplaceConstraint: users.uq_email (UNIQUE)"
    )]
    #[case::replace_constraint_unique_without_name(
        MigrationAction::ReplaceConstraint { table: "users".into(), from: uq_email(Some("uq_email")), to: uq_email(None) },
        "ReplaceConstraint: users.UNIQUE"
    )]
    #[case::replace_constraint_foreign_key_with_name(
        MigrationAction::ReplaceConstraint { table: "posts".into(), from: fk_user(None, None), to: fk_user(Some("fk_user"), None) },
        "ReplaceConstraint: posts.fk_user (FOREIGN KEY)"
    )]
    #[case::replace_constraint_foreign_key_without_name(
        MigrationAction::ReplaceConstraint { table: "posts".into(), from: fk_user(Some("fk_user"), None), to: fk_user(None, None) },
        "ReplaceConstraint: posts.FOREIGN KEY"
    )]
    #[case::replace_constraint_check(
        MigrationAction::ReplaceConstraint { table: "users".into(), from: chk("chk_age", "age > 0"), to: chk("chk_age", "age >= 0") },
        "ReplaceConstraint: users.chk_age (CHECK)"
    )]
    #[case::replace_constraint_index_with_name(
        MigrationAction::ReplaceConstraint { table: "users".into(), from: idx_email(None), to: idx_email(Some("ix_users__email")) },
        "ReplaceConstraint: users.ix_users__email (INDEX)"
    )]
    #[case::replace_constraint_index_without_name(
        MigrationAction::ReplaceConstraint { table: "users".into(), from: idx_email(Some("ix_users__email")), to: idx_email(None) },
        "ReplaceConstraint: users.INDEX"
    )]
    fn test_display_replace_constraint(#[case] action: MigrationAction, #[case] expected: &str) {
        assert_eq!(action.to_string(), expected);
    }

    #[test]
    fn test_action_with_prefix_replace_constraint() {
        let action = MigrationAction::ReplaceConstraint {
            table: "posts".into(),
            from: fk_user(Some("fk_user"), Some(ReferenceAction::Cascade)),
            to: fk_user(Some("fk_user"), Some(ReferenceAction::SetNull)),
        };
        let prefixed = action.with_prefix("myapp_");
        if let MigrationAction::ReplaceConstraint { table, from, to } = prefixed {
            assert_eq!(table.as_str(), "myapp_posts");
            if let TableConstraint::ForeignKey { ref_table, .. } = from {
                assert_eq!(ref_table.as_str(), "myapp_users");
            } else {
                panic!("Expected ForeignKey constraint in from");
            }
            if let TableConstraint::ForeignKey { ref_table, .. } = to {
                assert_eq!(ref_table.as_str(), "myapp_users");
            } else {
                panic!("Expected ForeignKey constraint in to");
            }
        } else {
            panic!("Expected ReplaceConstraint");
        }
    }
}