Fix sqlite mig issue

Author: owjs3901

Cargo.lock

@@ -16,12 +16,22 @@ pub fn apply_action(
             if schema.iter().any(|t| t.name == *table) {
                 return Err(PlannerError::TableExists(table.clone()));
             }
-            schema.push(TableDef {
+            let table_def = TableDef {
                 name: table.clone(),
                 description: None,
                 columns: columns.clone(),
                 constraints: constraints.clone(),
-            });
+            };
+            // Normalize to promote inline constraints (unique, index, foreign_key, primary_key)
+            // to table-level TableConstraint entries. This is critical for SQLite which needs
+            // to know about constraints when dropping columns.
+            let normalized = table_def.normalize().map_err(|e| {
+                PlannerError::TableValidation(format!(
+                    "Failed to normalize table '{}': {}",
+                    table, e
+                ))
+            })?;
+            schema.push(normalized);
             Ok(())
         }
         MigrationAction::DeleteTable { table } => {
@@ -49,6 +59,15 @@ pub fn apply_action(
                 ))
             } else {
                 tbl.columns.push((**column).clone());
+                // Re-normalize to promote any inline constraints on the new column
+                // to table-level TableConstraint entries.
+                let normalized = tbl.clone().normalize().map_err(|e| {
+                    PlannerError::TableValidation(format!(
+                        "Failed to normalize table '{}' after adding column '{}': {}",
+                        table, column.name, e
+                    ))
+                })?;
+                *tbl = normalized;
                 Ok(())
             }
         }
@@ -1142,6 +1161,146 @@ mod tests {
         assert!(schema[0].columns[0].index.is_none());
     }
 
+    // Tests for CreateTable normalizing inline constraints
+    #[test]
+    fn create_table_normalizes_inline_unique() {
+        let mut col_with_unique = col("email", ColumnType::Simple(SimpleColumnType::Text));
+        col_with_unique.unique = Some(vespertide_core::StrOrBoolOrArray::Bool(true));
+
+        let mut schema = vec![];
+        apply_action(
+            &mut schema,
+            &MigrationAction::CreateTable {
+                table: "users".into(),
+                columns: vec![col_with_unique],
+                constraints: vec![],
+            },
+        )
+        .unwrap();
+
+        // Inline unique: true should be normalized to a TableConstraint::Unique
+        assert!(
+            schema[0].constraints.iter().any(
+                |c| matches!(c, TableConstraint::Unique { columns, .. } if columns == &["email"])
+            ),
+            "Expected a Unique constraint on 'email', got: {:?}",
+            schema[0].constraints
+        );
+    }
+
+    #[test]
+    fn create_table_normalizes_inline_index() {
+        let mut col_with_index = col("email", ColumnType::Simple(SimpleColumnType::Text));
+        col_with_index.index = Some(vespertide_core::StrOrBoolOrArray::Bool(true));
+
+        let mut schema = vec![];
+        apply_action(
+            &mut schema,
+            &MigrationAction::CreateTable {
+                table: "users".into(),
+                columns: vec![col_with_index],
+                constraints: vec![],
+            },
+        )
+        .unwrap();
+
+        // Inline index: true should be normalized to a TableConstraint::Index
+        assert!(
+            schema[0].constraints.iter().any(
+                |c| matches!(c, TableConstraint::Index { columns, .. } if columns == &["email"])
+            ),
+            "Expected an Index constraint on 'email', got: {:?}",
+            schema[0].constraints
+        );
+    }
+
+    #[test]
+    fn create_table_normalizes_inline_primary_key() {
+        let mut col_with_pk = col("id", ColumnType::Simple(SimpleColumnType::Integer));
+        col_with_pk.primary_key =
+            Some(vespertide_core::schema::primary_key::PrimaryKeySyntax::Bool(true));
+
+        let mut schema = vec![];
+        apply_action(
+            &mut schema,
+            &MigrationAction::CreateTable {
+                table: "users".into(),
+                columns: vec![col_with_pk],
+                constraints: vec![],
+            },
+        )
+        .unwrap();
+
+        assert!(
+            schema[0].constraints.iter().any(
+                |c| matches!(c, TableConstraint::PrimaryKey { columns, .. } if columns == &["id"])
+            ),
+            "Expected a PrimaryKey constraint on 'id', got: {:?}",
+            schema[0].constraints
+        );
+    }
+
+    // Tests for AddColumn normalizing inline constraints
+    #[test]
+    fn add_column_normalizes_inline_unique() {
+        let mut schema = vec![table(
+            "users",
+            vec![col("id", ColumnType::Simple(SimpleColumnType::Integer))],
+            vec![],
+        )];
+
+        let mut col_with_unique = col("email", ColumnType::Simple(SimpleColumnType::Text));
+        col_with_unique.unique = Some(vespertide_core::StrOrBoolOrArray::Bool(true));
+
+        apply_action(
+            &mut schema,
+            &MigrationAction::AddColumn {
+                table: "users".into(),
+                column: Box::new(col_with_unique),
+                fill_with: None,
+            },
+        )
+        .unwrap();
+
+        assert!(
+            schema[0].constraints.iter().any(
+                |c| matches!(c, TableConstraint::Unique { columns, .. } if columns == &["email"])
+            ),
+            "Expected a Unique constraint on 'email' after AddColumn, got: {:?}",
+            schema[0].constraints
+        );
+    }
+
+    #[test]
+    fn add_column_normalizes_inline_index() {
+        let mut schema = vec![table(
+            "users",
+            vec![col("id", ColumnType::Simple(SimpleColumnType::Integer))],
+            vec![],
+        )];
+
+        let mut col_with_index = col("email", ColumnType::Simple(SimpleColumnType::Text));
+        col_with_index.index = Some(vespertide_core::StrOrBoolOrArray::Bool(true));
+
+        apply_action(
+            &mut schema,
+            &MigrationAction::AddColumn {
+                table: "users".into(),
+                column: Box::new(col_with_index),
+                fill_with: None,
+            },
+        )
+        .unwrap();
+
+        assert!(
+            schema[0].constraints.iter().any(
+                |c| matches!(c, TableConstraint::Index { columns, .. } if columns == &["email"])
+            ),
+            "Expected an Index constraint on 'email' after AddColumn, got: {:?}",
+            schema[0].constraints
+        );
+    }
+
     // Tests for ModifyColumnNullable
     #[test]
     fn apply_modify_column_nullable_success() {

crates/vespertide-planner/src/apply.rs

@@ -48,6 +48,7 @@ pub fn build_plan_queries(
 mod tests {
     use super::*;
     use crate::sql::DatabaseBackend;
+    use insta::{assert_snapshot, with_settings};
     use rstest::rstest;
     use vespertide_core::{
         ColumnDef, ColumnType, MigrationAction, MigrationPlan, SimpleColumnType,
@@ -117,6 +118,107 @@ mod tests {
         );
     }
 
+    fn build_sql_snapshot(result: &[BuiltQuery], backend: DatabaseBackend) -> String {
+        result
+            .iter()
+            .map(|q| q.build(backend))
+            .collect::<Vec<_>>()
+            .join(";\n")
+    }
+
+    /// Regression test: SQLite must emit DROP INDEX before DROP COLUMN when
+    /// the column was created with inline `unique: true` (no explicit table constraint).
+    /// Previously, apply_action didn't normalize inline constraints, so the evolving
+    /// schema had empty constraints and SQLite's DROP COLUMN failed.
+    #[rstest]
+    #[case::postgres("postgres", DatabaseBackend::Postgres)]
+    #[case::mysql("mysql", DatabaseBackend::MySql)]
+    #[case::sqlite("sqlite", DatabaseBackend::Sqlite)]
+    fn test_delete_column_after_create_table_with_inline_unique(
+        #[case] title: &str,
+        #[case] backend: DatabaseBackend,
+    ) {
+        let mut col_with_unique = col("gift_code", ColumnType::Simple(SimpleColumnType::Text));
+        col_with_unique.unique = Some(vespertide_core::StrOrBoolOrArray::Bool(true));
+
+        let plan = MigrationPlan {
+            comment: None,
+            created_at: None,
+            version: 1,
+            actions: vec![
+                MigrationAction::CreateTable {
+                    table: "gift".into(),
+                    columns: vec![
+                        col("id", ColumnType::Simple(SimpleColumnType::Integer)),
+                        col_with_unique,
+                    ],
+                    constraints: vec![], // No explicit constraints - only inline unique: true
+                },
+                MigrationAction::DeleteColumn {
+                    table: "gift".into(),
+                    column: "gift_code".into(),
+                },
+            ],
+        };
+
+        let result = build_plan_queries(&plan, &[]).unwrap();
+        let queries = match backend {
+            DatabaseBackend::Postgres => &result[1].postgres,
+            DatabaseBackend::MySql => &result[1].mysql,
+            DatabaseBackend::Sqlite => &result[1].sqlite,
+        };
+        let sql = build_sql_snapshot(queries, backend);
+
+        with_settings!({ snapshot_suffix => format!("inline_unique_{}", title) }, {
+            assert_snapshot!(sql);
+        });
+    }
+
+    /// Same regression test for inline `index: true`.
+    #[rstest]
+    #[case::postgres("postgres", DatabaseBackend::Postgres)]
+    #[case::mysql("mysql", DatabaseBackend::MySql)]
+    #[case::sqlite("sqlite", DatabaseBackend::Sqlite)]
+    fn test_delete_column_after_create_table_with_inline_index(
+        #[case] title: &str,
+        #[case] backend: DatabaseBackend,
+    ) {
+        let mut col_with_index = col("email", ColumnType::Simple(SimpleColumnType::Text));
+        col_with_index.index = Some(vespertide_core::StrOrBoolOrArray::Bool(true));
+
+        let plan = MigrationPlan {
+            comment: None,
+            created_at: None,
+            version: 1,
+            actions: vec![
+                MigrationAction::CreateTable {
+                    table: "users".into(),
+                    columns: vec![
+                        col("id", ColumnType::Simple(SimpleColumnType::Integer)),
+                        col_with_index,
+                    ],
+                    constraints: vec![],
+                },
+                MigrationAction::DeleteColumn {
+                    table: "users".into(),
+                    column: "email".into(),
+                },
+            ],
+        };
+
+        let result = build_plan_queries(&plan, &[]).unwrap();
+        let queries = match backend {
+            DatabaseBackend::Postgres => &result[1].postgres,
+            DatabaseBackend::MySql => &result[1].mysql,
+            DatabaseBackend::Sqlite => &result[1].sqlite,
+        };
+        let sql = build_sql_snapshot(queries, backend);
+
+        with_settings!({ snapshot_suffix => format!("inline_index_{}", title) }, {
+            assert_snapshot!(sql);
+        });
+    }
+
     #[test]
     fn test_build_plan_queries_sql_content() {
         let plan = MigrationPlan {

crates/vespertide-query/src/builder.rs

@@ -0,0 +1,5 @@
+---
+source: crates/vespertide-query/src/builder.rs
+expression: sql
+---
+ALTER TABLE `users` DROP COLUMN `email`