Idx issue

.changepacks/changepack_log_WVIEPiJN_k0LI81B8uE3A.json

@@ -0,0 +1 @@
+{"changes":{"crates/vespertide-planner/Cargo.toml":"Patch","crates/vespertide-query/Cargo.toml":"Patch","crates/vespertide/Cargo.toml":"Patch","crates/vespertide-core/Cargo.toml":"Patch","crates/vespertide-exporter/Cargo.toml":"Patch","crates/vespertide-config/Cargo.toml":"Patch","crates/vespertide-loader/Cargo.toml":"Patch","crates/vespertide-macro/Cargo.toml":"Patch","crates/vespertide-cli/Cargo.toml":"Patch","crates/vespertide-naming/Cargo.toml":"Patch"},"note":"Fix index, unique naming issue","date":"2025-12-19T06:56:36.275571Z"}

Cargo.toml

@@ -14,6 +14,7 @@ vespertide-core = { path = "crates/vespertide-core", version = "0.1.14" }
 vespertide-config = { path = "crates/vespertide-config", version = "0.1.14" }
 vespertide-loader = { path = "crates/vespertide-loader", version = "0.1.14" }
 vespertide-macro = { path = "crates/vespertide-macro", version = "0.1.14" }
+vespertide-naming = { path = "crates/vespertide-naming", version = "0.1.14" }
 vespertide-planner = { path = "crates/vespertide-planner", version = "0.1.14" }
 vespertide-query = { path = "crates/vespertide-query", version = "0.1.14" }
 vespertide-exporter = { path = "crates/vespertide-exporter", version = "0.1.14" }

crates/vespertide-cli/src/commands/diff.rs

@@ -89,24 +89,6 @@ fn format_action(action: &MigrationAction) -> String {
                 column.bright_cyan().bold()
             )
         }
-        MigrationAction::AddIndex { table, index } => {
-            format!(
-                "{} {} {} {}",
-                "Add index:".bright_green(),
-                index.name.bright_cyan().bold(),
-                "on".bright_white(),
-                table.bright_cyan()
-            )
-        }
-        MigrationAction::RemoveIndex { table, name } => {
-            format!(
-                "{} {} {} {}",
-                "Remove index:".bright_red(),
-                name.bright_cyan().bold(),
-                "from".bright_white(),
-                table.bright_cyan()
-            )
-        }
         MigrationAction::RenameTable { from, to } => {
             format!(
                 "{} {} {} {}",
@@ -171,6 +153,13 @@ fn format_constraint_type(constraint: &vespertide_core::TableConstraint) -> Stri
         vespertide_core::TableConstraint::Check { name, expr } => {
             format!("{} CHECK ({})", name, expr)
         }
+        vespertide_core::TableConstraint::Index { name, columns } => {
+            if let Some(n) = name {
+                format!("{} INDEX ({})", n, columns.join(", "))
+            } else {
+                format!("INDEX ({})", columns.join(", "))
+            }
+        }
     }
 }
 
@@ -230,7 +219,6 @@ mod tests {
                 auto_increment: false,
                 columns: vec!["id".into()],
             }],
-            indexes: vec![],
         };
         let path = models_dir.join(format!("{name}.json"));
         fs::write(path, serde_json::to_string_pretty(&table).unwrap()).unwrap();
@@ -284,19 +272,24 @@ mod tests {
         format!("{} {}.{}", "Modify column type:".bright_yellow(), "users".bright_cyan(), "id".bright_cyan().bold())
     )]
     #[case(
-        MigrationAction::AddIndex {
+        MigrationAction::AddConstraint {
             table: "users".into(),
-            index: vespertide_core::IndexDef {
-                name: "idx".into(),
+            constraint: vespertide_core::TableConstraint::Index {
+                name: Some("idx".into()),
                 columns: vec!["id".into()],
-                unique: false,
             },
         },
-        format!("{} {} {} {}", "Add index:".bright_green(), "idx".bright_cyan().bold(), "on".bright_white(), "users".bright_cyan())
+        format!("{} {} {} {}", "Add constraint:".bright_green(), "idx INDEX (id)".bright_cyan().bold(), "on".bright_white(), "users".bright_cyan())
     )]
     #[case(
-        MigrationAction::RemoveIndex { table: "users".into(), name: "idx".into() },
-        format!("{} {} {} {}", "Remove index:".bright_red(), "idx".bright_cyan().bold(), "from".bright_white(), "users".bright_cyan())
+        MigrationAction::RemoveConstraint {
+            table: "users".into(),
+            constraint: vespertide_core::TableConstraint::Index {
+                name: Some("idx".into()),
+                columns: vec!["id".into()],
+            },
+        },
+        format!("{} {} {} {}", "Remove constraint:".bright_red(), "idx INDEX (id)".bright_cyan().bold(), "from".bright_white(), "users".bright_cyan())
     )]
     #[case(
         MigrationAction::RenameTable { from: "users".into(), to: "accounts".into() },
@@ -433,4 +426,24 @@ mod tests {
         let result = cmd_diff();
         assert!(result.is_ok());
     }
+
+    #[test]
+    fn test_constraint_display_unnamed_index() {
+        let constraint = TableConstraint::Index {
+            name: None,
+            columns: vec!["email".into(), "username".into()],
+        };
+        let display = format_constraint_type(&constraint);
+        assert_eq!(display, "INDEX (email, username)");
+    }
+
+    #[test]
+    fn test_constraint_display_named_index() {
+        let constraint = TableConstraint::Index {
+            name: Some("ix_users_email".into()),
+            columns: vec!["email".into()],
+        };
+        let display = format_constraint_type(&constraint);
+        assert_eq!(display, "ix_users_email INDEX (email)");
+    }
 }

crates/vespertide-cli/src/commands/export.rs

@@ -261,7 +261,6 @@ mod tests {
                 auto_increment: false,
                 columns: vec!["id".into()],
             }],
-            indexes: vec![],
         }
     }
 

crates/vespertide-cli/src/commands/log.rs

@@ -58,36 +58,38 @@ pub fn cmd_log(backend: DatabaseBackend) -> Result<()> {
         }
 
         for (i, pq) in plan_queries.iter().enumerate() {
+            let queries = match backend {
+                DatabaseBackend::Postgres => &pq.postgres,
+                DatabaseBackend::MySql => &pq.mysql,
+                DatabaseBackend::Sqlite => &pq.sqlite,
+            };
+
+            // Build non-empty SQL statements
+            let sql_statements: Vec<String> = queries
+                .iter()
+                .map(|q| q.build(backend).trim().to_string())
+                .filter(|sql| !sql.is_empty())
+                .collect();
+
+            // Print action description
             println!(
                 "    {}. {}",
                 (i + 1).to_string().bright_magenta().bold(),
-                match backend {
-                    DatabaseBackend::Postgres => pq
-                        .postgres
-                        .iter()
-                        .map(|q| q.build(DatabaseBackend::Postgres))
-                        .collect::<Vec<_>>()
-                        .join(";\n")
-                        .trim()
-                        .bright_white(),
-                    DatabaseBackend::MySql => pq
-                        .mysql
-                        .iter()
-                        .map(|q| q.build(DatabaseBackend::MySql))
-                        .collect::<Vec<_>>()
-                        .join(";\n")
-                        .trim()
-                        .bright_white(),
-                    DatabaseBackend::Sqlite => pq
-                        .sqlite
-                        .iter()
-                        .map(|q| q.build(DatabaseBackend::Sqlite))
-                        .collect::<Vec<_>>()
-                        .join(";\n")
-                        .trim()
-                        .bright_white(),
-                }
+                pq.action.to_string().bright_cyan()
             );
+
+            // Print SQL statements with sub-numbering if multiple
+            for (j, sql) in sql_statements.iter().enumerate() {
+                let prefix = if sql_statements.len() > 1 {
+                    format!("    {}-{}.", i + 1, j + 1)
+                        .bright_magenta()
+                        .bold()
+                        .to_string()
+                } else {
+                    "      ".to_string()
+                };
+                println!("{} {}", prefix, sql.bright_white());
+            }
         }
 
         println!();
@@ -226,4 +228,54 @@ mod tests {
         let result = cmd_log(DatabaseBackend::Sqlite);
         assert!(result.is_ok());
     }
+
+    #[test]
+    #[serial_test::serial]
+    fn cmd_log_with_multiple_sql_statements() {
+        use vespertide_core::schema::primary_key::PrimaryKeySyntax;
+        use vespertide_core::{ColumnDef, ColumnType, SimpleColumnType};
+
+        let tmp = tempdir().unwrap();
+        let _guard = CwdGuard::new(&tmp.path().to_path_buf());
+
+        let cfg = VespertideConfig::default();
+        write_config(&cfg);
+        fs::create_dir_all(cfg.migrations_dir()).unwrap();
+
+        // Create a migration with ModifyColumnType for SQLite, which generates multiple SQL statements
+        let plan = MigrationPlan {
+            comment: Some("modify column type".into()),
+            created_at: Some("2024-01-01T00:00:00Z".into()),
+            version: 1,
+            actions: vec![
+                MigrationAction::CreateTable {
+                    table: "users".into(),
+                    columns: vec![ColumnDef {
+                        name: "id".into(),
+                        r#type: ColumnType::Simple(SimpleColumnType::Integer),
+                        nullable: false,
+                        default: None,
+                        comment: None,
+                        primary_key: Some(PrimaryKeySyntax::Bool(true)),
+                        unique: None,
+                        index: None,
+                        foreign_key: None,
+                    }],
+                    constraints: vec![],
+                },
+                MigrationAction::ModifyColumnType {
+                    table: "users".into(),
+                    column: "id".into(),
+                    new_type: ColumnType::Simple(SimpleColumnType::BigInt),
+                },
+            ],
+        };
+        let path = cfg.migrations_dir().join("0001_modify_column_type.json");
+        fs::write(path, serde_json::to_string_pretty(&plan).unwrap()).unwrap();
+
+        // SQLite backend will generate multiple SQL statements for ModifyColumnType (table recreation)
+        // This exercises line 84 where sql_statements.len() > 1
+        let result = cmd_log(DatabaseBackend::Sqlite);
+        assert!(result.is_ok());
+    }
 }

crates/vespertide-cli/src/commands/new.rs

@@ -32,7 +32,6 @@ pub fn cmd_new(name: String, format: Option<FileFormat>) -> Result<()> {
         name: name.clone(),
         columns: Vec::new(),
         constraints: Vec::new(),
-        indexes: Vec::new(),
     };
 
     match format {

crates/vespertide-cli/src/commands/revision.rs

@@ -178,7 +178,6 @@ mod tests {
                 auto_increment: false,
                 columns: vec!["id".into()],
             }],
-            indexes: vec![],
         };
         let path = models_dir.join(format!("{name}.json"));
         fs::write(path, serde_json::to_string_pretty(&table).unwrap()).unwrap();

crates/vespertide-cli/src/commands/sql.rs

@@ -163,7 +163,6 @@ mod tests {
                 auto_increment: false,
                 columns: vec!["id".into()],
             }],
-            indexes: vec![],
         };
         let path = models_dir.join(format!("{name}.json"));
         fs::write(path, serde_json::to_string_pretty(&table).unwrap()).unwrap();
@@ -399,12 +398,11 @@ mod tests {
                     }],
                     constraints: vec![],
                 },
-                MigrationAction::AddIndex {
+                MigrationAction::AddConstraint {
                     table: "users".into(),
-                    index: vespertide_core::IndexDef {
-                        name: "idx_id".into(),
+                    constraint: TableConstraint::Index {
+                        name: Some("idx_id".into()),
                         columns: vec!["id".into()],
-                        unique: false,
                     },
                 },
             ],
@@ -463,7 +461,6 @@ mod tests {
                 auto_increment: false,
                 columns: vec!["id".into()],
             }],
-            indexes: vec![],
         }];
 
         let result = emit_sql(&plan, DatabaseBackend::Sqlite, &current_schema);