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
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100

use anyhow::Result;
use std::path::{Path, PathBuf};

use crate::catalog::Catalog;
use crate::db::connection::connect_with_retry_quiet;
use crate::db::sql_executor::{SqlExecutorConfig, discover_sql_files_ordered, execute_sql_file};

/// Import schema from a directory of SQL files
pub async fn import_from_directory(
    dir: PathBuf,
    shadow_url: &str,
    roles_file: Option<&Path>,
    objects: &crate::config::types::Objects,
) -> Result<Catalog> {
    // Discover SQL files in alphabetical order
    let sql_files = discover_sql_files_ordered(&dir)?;

    tracing::debug!("Found {} SQL files. Executing in order...", sql_files.len());

    // Connect to shadow database with retry logic (quiet mode to avoid slow query logging)
    let pool = connect_with_retry_quiet(shadow_url).await?;

    // Reset the managed universe before importing — custom shadow images
    // preinstall extensions/schemas via init scripts (see import_from_sql_file).
    crate::db::cleaner::clean_shadow_db(&pool, objects).await?;

    // Apply roles file first if it exists (roles must exist before GRANTs)
    if let Some(roles_path) = roles_file
        && roles_path.exists()
    {
        tracing::debug!("Applying roles from: {}", roles_path.display());
        crate::schema_ops::apply_roles_file(&pool, roles_path).await?;
    }

    // Configure SQL executor for import scenario (quiet mode for init)
    let executor_config = SqlExecutorConfig {
        initialize_session: true,
        verbose: false,
    };

    // Execute each file - errors bubble up with line numbers already formatted
    for file in &sql_files {
        execute_sql_file(&pool, file, &executor_config).await?;
    }

    // Extract catalog
    // Physical-world load: init applies the objects filter at a single
    // point after the substrate-exclusion prompt (scoping isn't final here).
    let catalog = Catalog::load_unfiltered(&pool).await?;

    // Cleanup
    pool.close().await;
    // Note: Docker containers are automatically cleaned up based on their auto_cleanup configuration

    Ok(catalog)
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::env;

    #[test]
    fn test_import_directory_basic_structure() {
        let temp_dir = env::temp_dir().join("pgmt_test_import_directory");
        let _ = std::fs::remove_dir_all(&temp_dir);
        std::fs::create_dir_all(&temp_dir).unwrap();

        // Create test SQL files
        std::fs::write(temp_dir.join("01_schema.sql"), "CREATE SCHEMA test;").unwrap();
        std::fs::write(
            temp_dir.join("02_tables.sql"),
            "CREATE TABLE test.users (id SERIAL);",
        )
        .unwrap();

        // Test file discovery
        let files = discover_sql_files_ordered(&temp_dir).unwrap();
        assert_eq!(files.len(), 2);
        assert!(
            files[0]
                .file_name()
                .unwrap()
                .to_str()
                .unwrap()
                .starts_with("01_")
        );
        assert!(
            files[1]
                .file_name()
                .unwrap()
                .to_str()
                .unwrap()
                .starts_with("02_")
        );

        // Cleanup
        let _ = std::fs::remove_dir_all(&temp_dir);
    }
}