Files
creddy/src/db/migrations.rs
T

175 lines
5.8 KiB
Rust

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<Migration> {
let mut migrations: Vec<Migration> = 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<Vec<String>, CreddyError> {
let mut stmt = conn.prepare("SELECT id FROM _migrations ORDER BY id;")?;
let ids = stmt
.query_map([], |row| row.get(0))?
.collect::<Result<Vec<String>, _>>()?;
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<bool> {
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(())
}
}