qail 0.27.10

Schema-first database toolkit - migrations, diff, lint, and query generation
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

//! Migration status operations

use crate::colors::*;
use anyhow::Result;
use qail_core::prelude::*;
use qail_pg::PgDriver;

use crate::migrations::ensure_migration_table;
use crate::util::parse_pg_url;

/// Show migration status and history.
pub async fn migrate_status(url: &str) -> Result<()> {
    println!("{}", "📋 Migration Status".cyan().bold());
    println!();

    let (host, port, user, password, database) = parse_pg_url(url)?;
    let mut driver = if let Some(pwd) = password {
        PgDriver::connect_with_password(&host, port, &user, &database, &pwd)
            .await
            .map_err(|e| anyhow::anyhow!("Failed to connect: {}", e))?
    } else {
        PgDriver::connect(&host, port, &user, &database)
            .await
            .map_err(|e| anyhow::anyhow!("Failed to connect: {}", e))?
    };

    // Ensure migration table exists (AST-native bootstrap)
    ensure_migration_table(&mut driver)
        .await
        .map_err(|e| anyhow::anyhow!("Failed to create migration table: {}", e))?;

    println!("  Database: {}", database.yellow());
    println!("  Migration table: {}", "_qail_migrations".green());
    println!();

    // Query migration history with column data
    let status_cmd = Qail::get("_qail_migrations")
        .columns(vec!["version", "name", "applied_at", "checksum"])
        .order_by("applied_at", SortOrder::Desc);

    match driver.query_ast(&status_cmd).await {
        Ok(result) => {
            if result.rows.is_empty() {
                println!("  {} No migrations applied yet", "â—‹".dimmed());
                println!();
                println!("  Run {} to apply migrations", "qail migrate up".cyan());
                return Ok(());
            }

            // Print migration history table
            println!(
                "  {} {} migration(s) applied\n",
                "✓".green(),
                result.rows.len().to_string().green()
            );

            // Header
            println!(
                "  {}  {}  {}  {}",
                format!("{:<14}", "VERSION").cyan().bold(),
                format!("{:<30}", "NAME").cyan().bold(),
                format!("{:<25}", "APPLIED AT").cyan().bold(),
                "CHECKSUM".cyan().bold(),
            );
            println!("  {}", "─".repeat(85).dimmed());

            // Rows
            for row in &result.rows {
                let version = row
                    .first()
                    .and_then(|v| v.as_ref())
                    .map(|s| s.as_str())
                    .unwrap_or("?");
                let name = row
                    .get(1)
                    .and_then(|v| v.as_ref())
                    .map(|s| s.as_str())
                    .unwrap_or("-");
                let applied_at = row
                    .get(2)
                    .and_then(|v| v.as_ref())
                    .map(|s| s.as_str())
                    .unwrap_or("-");
                let checksum = row
                    .get(3)
                    .and_then(|v| v.as_ref())
                    .map(|s| s.as_str())
                    .unwrap_or("-");

                // Truncate checksum for display
                let checksum_short = if checksum.len() > 12 {
                    format!("{}…", &checksum[..12])
                } else {
                    checksum.to_string()
                };

                // Truncate applied_at to remove microseconds
                let applied_short = if applied_at.len() > 19 {
                    &applied_at[..19]
                } else {
                    applied_at
                };

                println!(
                    "  {:<14}  {:<30}  {:<25}  {}",
                    version.white(),
                    name,
                    applied_short.dimmed(),
                    checksum_short.dimmed(),
                );
            }

            println!();
            println!(
                "  Run {} to rollback by version",
                "qail migrate rollback --to".cyan()
            );
        }
        Err(e) => {
            return Err(anyhow::anyhow!(
                "Failed to query migration history from _qail_migrations: {}",
                e
            ));
        }
    }

    Ok(())
}