swellow 0.2.0

SQL-first migration CLI
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

mod cli;
mod db;
mod parser;

pub use cli::error::SwellowError;
pub use parser::migration;

use clap::Parser;
use cli::{commands, error, output, ux};
use output::{SwellowOutput, SwellowStatus};
use serde_json::Value;


async fn run_command(args: &cli::Cli) -> output::SwellowOutput<serde_json::Value> {
    let command_name = args.command.to_string();
    
    if let Err(e) = ux::setup_logging(args.verbose, args.quiet, args.json) {
        return SwellowOutput {
            command: "setup_logging".to_string(),
            status: SwellowStatus::Error,
            data: None,
            error: Some((&e).into()),
            timestamp: chrono::Utc::now(),
        }
    };

    let db_connection_string: String = args.db_connection_string.clone();
    let migration_directory: String = args.migration_directory.clone();

    let mut backend = match args.engine.into_backend(db_connection_string).await {
        Ok(b) => b,
        Err(e) => return SwellowOutput {
            command: command_name,
            status: SwellowStatus::Error,
            data: None,
            error: Some((&e).into()),
            timestamp: chrono::Utc::now(),
        }
    };

    let mut output: SwellowOutput<Value> = match &args.command {
        cli::Commands::Peck { } => SwellowOutput::from_result(
            "peck",
            commands::peck(&mut backend).await
        ),
        cli::Commands::Up { args } => SwellowOutput::from_result(
            "up",
            commands::migrate(
                &mut backend,
                &migration_directory,
                args.current_version_id,
                args.target_version_id,
                migration::MigrationDirection::Up,
                args.plan,
                args.dry_run,
                args.no_transaction,
                args.ignore_locks,
            ).await
        ),
        cli::Commands::Down { args } => SwellowOutput::from_result(
            "down",
            commands::migrate(
                &mut backend,
                &migration_directory,
                args.current_version_id,
                args.target_version_id,
                migration::MigrationDirection::Down,
                args.plan,
                args.dry_run,
                args.no_transaction,
                args.ignore_locks,
            ).await
        ),
        cli::Commands::Snapshot { } => SwellowOutput::from_result(
            "snapshot",
            commands::snapshot(
                &mut backend,
                &migration_directory
            ).await
        ),
    };

    // Try to release lock, but don't overwrite an existing error
    if let Err(e) = backend.release_lock().await {
        if output.status == SwellowStatus::Success {
            // Only override if the main command succeeded
            output.status = SwellowStatus::Error;
            output.error = Some((&e).into());
        } else {
            // Otherwise log it
            tracing::error!("Failed to release lock: {e}");
        }
    }

    output
}


/// Entry point for the Swellow CLI tool.
///
/// This program manages database migrations by delegating to subcommands:
/// - `peck`: Verify connectivity to the database.
/// - `up`: Apply migrations forward from the current to target version.
/// - `down`: Revert migrations backward from the current to target version.
/// - `snapshot`: Create a snapshot of the current migration state.
///
/// Arguments such as `--db` and `--dir` are parsed from the command line
/// and passed through to the relevant command handlers.
#[tokio::main]
async fn main() {
    let args: cli::Cli = cli::Cli::parse();

    let result = run_command(&args).await;

    // Serialize JSON safely
    if args.json {
        match serde_json::to_string_pretty(&result) {
            Ok(json) => println!("{}", json),
            Err(e) => {
                tracing::error!("Failed to serialize output to JSON: {:?}", e);
                std::process::exit(1);
            }
        }
    }

    // Handle error output safely
    if let SwellowStatus::Error = result.status {
        if let Some(err) = result.error {
            tracing::error!("'swellow {}' failed: {:?}", result.command, err);
        } else {
            tracing::error!("'swellow {}' failed with unknown error", result.command);
        }
        std::process::exit(1);
    }
}