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
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

use std::process::Command;

use anstream::println;
use chrono::Utc;
use clap::Parser;
use eyre::eyre;
use owo_colors::OwoColorize;
use sha2::{Digest, Sha256};
use tracing::instrument;

use crate::{
    App,
    db::get_db_adapter,
    error::Result,
    migration::{
        dir::get_migrations_dir,
        planner::{MigrationState, Planner},
    },
};

/// Squash all applied migrations into a single baseline migration
#[derive(Debug, Parser)]
pub struct Rollup {}

impl Rollup {
    #[instrument(name = "rollup", skip_all)]
    pub fn run(&self, opts: &App) -> Result {
        let migrations_dir = get_migrations_dir(opts);
        let local = migrations_dir.load()?;

        let mut db = get_db_adapter(opts)?;

        // Error out if status is not clean
        if Planner::new(opts)?
            .status()?
            .iter()
            .any(|s| s.state != MigrationState::Applied)
        {
            return Err(eyre!(
                "cannot rollup when there are pending, variant, or divergent migrations"
            ));
        }

        let url = &opts.options.url;

        // Dump current schema excluding the migrations table
        let up_sql = if url.starts_with("postgres://") || url.starts_with("postgresql://") {
            let out = Command::new("pg_dump")
                .arg("--schema-only")
                .arg("--no-owner")
                .arg("--no-privileges")
                .arg("--exclude-schema=crude")
                .arg(format!("--dbname={url}"))
                .output()?;

            String::from_utf8_lossy(&out.stdout).into_owned()
        } else {
            let out = Command::new("sqlite3").arg(url).arg(".schema").output()?;

            String::from_utf8_lossy(&out.stdout)
                .lines()
                .filter(|l| !l.contains("crude_migrations"))
                .collect::<Vec<_>>()
                .join("\n")
        };

        // Build baseline migration
        let ts = Utc::now();
        let compound_name = format!("{}_rollup", ts.format("%Y%m%d%H%M%S"));

        let mut hasher = Sha256::new();
        hasher.update(up_sql.as_bytes());
        let hash = hex::encode(hasher.finalize());

        // Dump data-only SQL for seed (exclude migrations table)
        let seed_sql = if url.starts_with("postgres://") || url.starts_with("postgresql://") {
            let out = Command::new("pg_dump")
                .arg("--data-only")
                .arg("--inserts")
                .arg("--no-owner")
                .arg("--no-privileges")
                .arg("--exclude-schema=crude")
                .arg(format!("--dbname={url}"))
                .output()?;

            String::from_utf8_lossy(&out.stdout).into_owned()
        } else {
            let out = Command::new("sqlite3").arg(url).arg(".dump").output()?;

            String::from_utf8_lossy(&out.stdout)
                .lines()
                .filter(|l| !l.contains("crude_migrations"))
                .collect::<Vec<_>>()
                .join("\n")
        };

        // Create the rollup migration
        migrations_dir.create_migration(&compound_name, Some(&up_sql), Some(&seed_sql))?;

        // Reset migration history and apply baseline record
        db.clear_migrations()?;
        db.record_baseline(&compound_name, &hash)?;

        // Remove all other migrations including previous rollup
        local
            .iter()
            .filter(|m| m.name != "init")
            .try_for_each(|m| {
                println!("{} {}", "Rolled up".cyan(), m.compound_name);

                migrations_dir.remove_migration(&m.compound_name)
            })?;

        Ok(())
    }
}