pgmt 0.5.0

PostgreSQL migration tool that keeps your schema files as the source of truth
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
84

//! pgmt migrate diff - Detect schema drift in target database
//!
//! This command compares the target (production) database against your
//! schema files to detect drift - changes made outside of migrations.
//!
//! Use this in CI/CD pipelines to ensure production matches the expected schema.

use crate::catalog::Catalog;
use crate::commands::diff_output::{DiffContext, DiffFormat, has_differences, output_diff};
use crate::config::{Config, ObjectFilter};
use crate::diff::plan;
use crate::schema_ops::apply_current_schema_to_shadow;
use anyhow::Result;
use std::path::Path;

/// Arguments for migrate diff command
#[derive(Debug)]
pub struct MigrateDiffArgs {
    pub format: DiffFormat,
    pub output_sql: Option<String>,
}

impl Default for MigrateDiffArgs {
    fn default() -> Self {
        Self {
            format: DiffFormat::Detailed,
            output_sql: None,
        }
    }
}

/// Detect drift between schema files and target database
///
/// Compares your schema files (source of truth) against the target database
/// to detect any drift - changes that were made outside of the migration process.
///
/// Exit codes:
/// - 0: No drift detected, target matches schema
/// - 1: Drift detected, target differs from schema
pub async fn cmd_migrate_diff(
    config: &Config,
    root_dir: &Path,
    args: MigrateDiffArgs,
    target: &crate::config::TargetUrl,
    shadow: &crate::config::ShadowDatabase,
) -> Result<()> {
    eprintln!("Checking target database for drift...\n");

    // Load schema into shadow database
    eprintln!("Loading schema files...");
    let schema_catalog = apply_current_schema_to_shadow(config, root_dir, shadow).await?;

    // Load target database catalog
    eprintln!("Loading target database...");
    let target_pool =
        crate::db::connection::connect_to_database(target.as_str(), "target database").await?;
    let filter = ObjectFilter::from_config(config);
    let target_catalog = Catalog::load_managed(&target_pool, &filter).await?;

    // Compute differences (target -> schema, so SQL shows how to fix target)
    eprintln!("Computing differences...\n");
    let ordered_steps = plan(&target_catalog, &schema_catalog)?;

    // Output results
    let context = DiffContext::new("target database", "schema files");
    output_diff(
        &ordered_steps,
        &args.format,
        &context,
        &target_catalog,
        &schema_catalog,
        args.output_sql.as_deref(),
    )?;

    // Exit with code 1 if drift detected
    if has_differences(&ordered_steps) {
        eprintln!("\nDrift detected! Target database differs from schema files.");
        std::process::exit(1);
    } else {
        eprintln!("No drift detected. Target database matches schema files.");
    }

    Ok(())
}