waypoint-core 0.4.0

Lightweight, Flyway-compatible SQL migration library for PostgreSQL and MySQL
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
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153

//! Standalone `waypoint safety` command for analyzing migration files.

use serde::Serialize;

#[cfg(feature = "postgres")]
use tokio_postgres::Client;

use crate::config::WaypointConfig;
use crate::db::DbClient;
use crate::error::Result;
use crate::safety;

/// Report from the standalone safety analysis command.
#[derive(Debug, Clone, Serialize)]
pub struct SafetyCommandReport {
    /// Per-file safety reports.
    pub reports: Vec<safety::SafetyReport>,
    /// Overall verdict across all files.
    pub overall_verdict: safety::SafetyVerdict,
}

/// Analyze a single migration file for safety (PostgreSQL legacy entry).
#[cfg(feature = "postgres")]
pub async fn execute_file(
    client: &Client,
    config: &WaypointConfig,
    file_path: &str,
) -> Result<safety::SafetyReport> {
    let sql = std::fs::read_to_string(file_path)?;
    let script = filename_from_path(file_path);
    safety::analyze_migration(
        client,
        &config.migrations.schema,
        &sql,
        &script,
        &config.safety,
    )
    .await
}

/// Analyze a single migration file for safety (dialect-aware entry).
pub async fn execute_file_db(
    client: &DbClient,
    config: &WaypointConfig,
    file_path: &str,
) -> Result<safety::SafetyReport> {
    let sql = std::fs::read_to_string(file_path)?;
    let script = filename_from_path(file_path);
    let schema = client.resolve_schema(&config.migrations.schema).await?;
    safety::analyze_migration_db(client, &schema, &sql, &script, &config.safety).await
}

fn filename_from_path(file_path: &str) -> String {
    std::path::Path::new(file_path)
        .file_name()
        .map(|f| f.to_string_lossy().to_string())
        .unwrap_or_else(|| file_path.to_string())
}

/// Analyze all pending migration files for safety (PostgreSQL legacy entry).
#[cfg(feature = "postgres")]
pub async fn execute(client: &Client, config: &WaypointConfig) -> Result<SafetyCommandReport> {
    use crate::history;
    use crate::migration::scan_migrations;

    let schema = &config.migrations.schema;
    let table = &config.migrations.table;

    history::create_history_table(client, schema, table).await?;
    let resolved = scan_migrations(&config.migrations.locations)?;
    let applied = history::get_applied_migrations(client, schema, table).await?;
    let effective = history::effective_applied_versions(&applied);

    let mut reports = Vec::new();
    let mut overall = safety::SafetyVerdict::Safe;

    for migration in &resolved {
        if migration.is_undo() {
            continue;
        }
        if let Some(version) = migration.version() {
            if effective.contains(&version.raw) {
                continue;
            }
        }

        let report = safety::analyze_migration(
            client,
            schema,
            &migration.sql,
            &migration.script,
            &config.safety,
        )
        .await?;

        if report.overall_verdict > overall {
            overall = report.overall_verdict;
        }
        reports.push(report);
    }

    Ok(SafetyCommandReport {
        reports,
        overall_verdict: overall,
    })
}

/// Analyze all pending migration files for safety (dialect-aware entry).
pub async fn execute_db(client: &DbClient, config: &WaypointConfig) -> Result<SafetyCommandReport> {
    use crate::history;
    use crate::migration::scan_migrations;

    let schema = client.resolve_schema(&config.migrations.schema).await?;
    let table = &config.migrations.table;

    history::create_history_table_db(client, &schema, table).await?;
    let resolved = scan_migrations(&config.migrations.locations)?;
    let applied = history::get_applied_migrations_db(client, &schema, table).await?;
    let effective = history::effective_applied_versions(&applied);

    let mut reports = Vec::new();
    let mut overall = safety::SafetyVerdict::Safe;

    for migration in &resolved {
        if migration.is_undo() {
            continue;
        }
        if let Some(version) = migration.version() {
            if effective.contains(&version.raw) {
                continue;
            }
        }

        let report = safety::analyze_migration_db(
            client,
            &schema,
            &migration.sql,
            &migration.script,
            &config.safety,
        )
        .await?;

        if report.overall_verdict > overall {
            overall = report.overall_verdict;
        }
        reports.push(report);
    }

    Ok(SafetyCommandReport {
        reports,
        overall_verdict: overall,
    })
}