crude 0.1.0

Migration toolkit for databases
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

use std::{fs::write, process::Command};

use ::postgres::{Client, NoTls};
use eyre::eyre;
use rusqlite::Connection;
use tracing::debug;

use crate::{App, error::Result, migration::Migration};

mod postgres;
mod sqlite;

pub use postgres::PostgresAdapter;
pub use sqlite::SqliteAdapter;

/// Trait that defines database operations for migrations.
pub trait DatabaseAdapter {
    /// SQL to initialize the migrations tracking table.
    fn init_up_sql(&self) -> &'static str;

    /// Load applied migrations from the database.
    fn load_migrations(&mut self) -> Result<Vec<Migration>>;

    /// Run an UP migration and record it.
    fn run_up_migration(&mut self, migration: &Migration) -> Result<()>;

    /// Run a DOWN migration and remove it.
    fn run_down_migration(&mut self, migration: &Migration) -> Result<()>;

    /// Update the hash of a migration.
    fn update_migration_hash(&mut self, name: &str, hash: &str) -> Result<()>;

    /// Clear all recorded migrations from the tracking table.
    fn clear_migrations(&mut self) -> Result<()>;

    /// Record a baseline migration in the tracking table without executing its SQL.
    fn record_baseline(&mut self, name: &str, hash: &str) -> Result<()>;
}

/// Build a boxed DatabaseAdapter (Postgres or SQLite) based on the URL.
pub fn get_db_adapter(opts: &App) -> Result<Box<dyn DatabaseAdapter>> {
    let url = &opts.options.url;

    if url.starts_with("postgres://") || url.starts_with("postgresql://") {
        let client = Client::connect(url, NoTls)?;

        Ok(Box::new(PostgresAdapter::new(client)))
    } else if url.starts_with("sqlite://") {
        let conn = Connection::open(url)?;

        Ok(Box::new(SqliteAdapter::new(conn)))
    } else {
        Err(eyre!("unsupported database URL: {}", url))
    }
}

/// If the user specified a schema file, dump to it
pub fn maybe_dump_schema(opts: &App) -> Result<()> {
    if let Some(path) = &opts.options.schema {
        let url = &opts.options.url;

        if url.starts_with("postgres://") || url.starts_with("postgresql://") {
            // Use external pg_dump for schema-only dump
            let output = Command::new("pg_dump")
                .arg("--schema-only")
                .arg("--no-owner")
                .arg("--no-privileges")
                .arg(format!("--dbname={url}"))
                .output()?;

            write(path, &output.stdout)?;
        } else if url.starts_with("sqlite://") {
            // SQLite schema via sqlite3 .schema
            let output = Command::new("sqlite3").arg(url).arg(".schema").output()?;

            write(path, &output.stdout)?;
        }

        debug!("schema dumped to {path}");
    }

    Ok(())
}