use duckdb::Connection; use include_dir::{Dir, include_dir}; use crate::error::CreddyError; static MIGRATIONS_DIR: Dir = include_dir!("$CARGO_MANIFEST_DIR/migrations"); struct Migration { id: &'static str, sql: &'static str, } /// Run all unapplied database migrations. pub fn migrate(conn: &mut Connection) -> Result<(), CreddyError> { apply_migrations(conn, &embedded_migrations()) } /// Sorted list of migration files, checked for utf-8-ness at compile time. fn embedded_migrations() -> Vec { let mut migrations: Vec = MIGRATIONS_DIR .files() .filter(|f| f.path().extension().is_some_and(|ext| ext == "sql")) .map(|f| Migration { // these are baked in at compile time, so a bad file is a build problem, not a runtime one id: f.path().file_name().and_then(|n| n.to_str()).expect("migration filename is not UTF-8"), sql: f.contents_utf8().expect("migration file is not UTF-8"), }) .collect(); migrations.sort_by_key(|m| m.id); migrations } /// Run a specific list of migrations. (Makes testing easier than always hard-coding) fn apply_migrations(conn: &mut Connection, known: &[Migration]) -> Result<(), CreddyError> { create_migrations_table(conn)?; let applied = list_applied_migrations(conn)?; // the applied migrations must be exactly the first N known ones for (i, id) in applied.iter().enumerate() { if known.get(i).is_some_and(|m| m.id == id) { continue; } // at this point, either known[i] doesn't exist or doesn't match `id` if known.iter().any(|m| m.id == id) { return Err(CreddyError::MigrationOutOfOrder(id.clone())); } // return Err(CreddyError::DbTooNew(id.clone())); } for migration in &known[applied.len()..] { let tx = conn.transaction()?; tx.execute_batch(migration.sql)?; tx.execute("INSERT INTO _migrations (id) VALUES (?);", [migration.id])?; tx.commit()?; } Ok(()) } /// Create the migrations table if it doesn't exist already. fn create_migrations_table(conn: &Connection) -> Result<(), CreddyError> { conn.execute_batch( "CREATE TABLE IF NOT EXISTS _migrations ( id VARCHAR PRIMARY KEY, applied_at TIMESTAMPTZ NOT NULL DEFAULT current_timestamp );", )?; Ok(()) } /// List migrations that have been applied to this database, in the order they were applied. fn list_applied_migrations(conn: &Connection) -> Result, CreddyError> { let mut stmt = conn.prepare("SELECT id FROM _migrations ORDER BY id;")?; let ids = stmt .query_map([], |row| row.get(0))? .collect::, _>>()?; Ok(ids) } #[cfg(test)] mod tests { use testresult::TestResult; use super::*; const FIRST: Migration = Migration { id: "0001_first.sql", sql: "CREATE TABLE a (x INTEGER);", }; const SECOND: Migration = Migration { id: "0002_second.sql", sql: "CREATE TABLE b (x INTEGER); INSERT INTO b VALUES (1);", }; fn table_exists(conn: &Connection, name: &str) -> duckdb::Result { conn.query_row( "SELECT count(*) > 0 FROM duckdb_tables() WHERE table_name = ?;", [name], |row| row.get(0), ) } #[test] fn test_embedded_migrations_apply() -> TestResult { let mut conn = Connection::open_in_memory()?; migrate(&mut conn)?; let applied = list_applied_migrations(&conn)?; let expected: Vec<_> = embedded_migrations().iter().map(|m| m.id.to_string()).collect(); assert_eq!(applied, expected); Ok(()) } #[test] fn test_apply_incrementally() -> TestResult { let mut conn = Connection::open_in_memory()?; apply_migrations(&mut conn, &[FIRST])?; assert_eq!(list_applied_migrations(&conn)?, ["0001_first.sql"]); // already-applied migrations are skipped, so re-running FIRST would fail if it weren't apply_migrations(&mut conn, &[FIRST, SECOND])?; assert_eq!(list_applied_migrations(&conn)?, ["0001_first.sql", "0002_second.sql"]); assert!(table_exists(&conn, "b")?); Ok(()) } #[test] fn test_failed_migration_rolls_back() -> TestResult { let mut conn = Connection::open_in_memory()?; let broken = Migration { id: "0002_broken.sql", sql: "CREATE TABLE b (x INTEGER); this is not sql;", }; let res = apply_migrations(&mut conn, &[FIRST, broken]); assert!(matches!(res, Err(CreddyError::Db(_)))); // FIRST stays applied, but nothing from the broken migration survives assert_eq!(list_applied_migrations(&conn)?, ["0001_first.sql"]); assert!(table_exists(&conn, "a")?); assert!(!table_exists(&conn, "b")?); Ok(()) } #[test] fn test_db_too_new() -> TestResult { let mut conn = Connection::open_in_memory()?; apply_migrations(&mut conn, &[FIRST, SECOND])?; // simulates running an older version of the app, which doesn't know about SECOND match apply_migrations(&mut conn, &[FIRST]) { Err(CreddyError::DbTooNew(id)) => assert_eq!(id, "0002_second.sql"), res => panic!("Expected DbTooNew, got {res:?}"), } Ok(()) } #[test] fn test_migration_out_of_order() -> TestResult { let mut conn = Connection::open_in_memory()?; apply_migrations(&mut conn, &[SECOND])?; // FIRST sorts before an already-applied migration, so it was added after the fact match apply_migrations(&mut conn, &[FIRST, SECOND]) { Err(CreddyError::MigrationOutOfOrder(id)) => assert_eq!(id, "0002_second.sql"), res => panic!("Expected MigrationOutOfOrder, got {res:?}"), } Ok(()) } }