pgevolve 0.4.6

Postgres declarative schema management CLI — diff source SQL against a live database and generate reviewable migrations.
Documentation 
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

//! `pgevolve cluster status` — list cluster plans.
//!
//! Prints the name of each subdirectory under `cluster-plans/`, sorted
//! lexicographically (which matches chronological order given that the plan id
//! is derived from a stable hash).
//!
//! v0.3.0 gap: the per-DB `status` command reads `pgevolve.apply_log` to mark
//! each plan as applied vs. pending. Cluster apply does not yet write to an
//! apply log (`pgevolve.apply_log` is per-DB). Tracking apply history for
//! cluster plans is deferred to Stage 12 / v0.3.0 hardening.

use std::path::Path;

use anyhow::{Context, Result};

use crate::cluster_config::ClusterConfig;

/// Run `pgevolve cluster status`.
pub fn run(project_root: &Path, _cfg: &ClusterConfig) -> Result<i32> {
    let plans_root = project_root.join("cluster-plans");
    if !plans_root.exists() {
        println!("No cluster plans.");
        return Ok(0);
    }

    let mut entries: Vec<_> = std::fs::read_dir(&plans_root)
        .with_context(|| format!("reading {}", plans_root.display()))?
        .filter_map(Result::ok)
        .filter(|e| e.file_type().is_ok_and(|t| t.is_dir()))
        .collect();

    // Sort lexicographically so output is deterministic.
    entries.sort_by_key(std::fs::DirEntry::path);

    if entries.is_empty() {
        println!("No cluster plans.");
        return Ok(0);
    }

    for entry in entries {
        println!("{}", entry.file_name().to_string_lossy());
    }

    Ok(0)
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::cluster_config::ClusterConfig;

    fn dummy_cfg() -> ClusterConfig {
        toml::from_str(
            r#"
            [project]
            name = "test"
            [connection]
            dsn = "postgres://localhost"
        "#,
        )
        .unwrap()
    }

    #[test]
    fn prints_no_cluster_plans_when_directory_absent() {
        let dir = tempfile::tempdir().unwrap();
        // No cluster-plans dir exists; should return 0 without error.
        let code = run(dir.path(), &dummy_cfg()).unwrap();
        assert_eq!(code, 0);
    }

    #[test]
    fn lists_plan_dirs() {
        let dir = tempfile::tempdir().unwrap();
        let plans = dir.path().join("cluster-plans");
        std::fs::create_dir(&plans).unwrap();
        std::fs::create_dir(plans.join("aabbccdd")).unwrap();
        std::fs::create_dir(plans.join("eeff0011")).unwrap();
        // Should succeed and (visually) print both dirs.
        let code = run(dir.path(), &dummy_cfg()).unwrap();
        assert_eq!(code, 0);
    }
}