appstruct-cli 0.2.0

Command-line compiler and development workflow for AppStruct applications
use appstruct_migrate::{
    ApplyReport, DriftStatus, MigrationError, MigrationStatus, apply_project, status_project,
};
use std::env;
use std::path::Path;
use std::process::ExitCode;

pub(super) fn apply(project: &Path, configured_url: Option<&str>) -> ExitCode {
    let Some(database_url) = database_url(configured_url) else {
        return crate::report::fail(
            "AS4107",
            crate::report::ErrorCategory::Configuration,
            "DATABASE_URL is required for migrate apply",
            crate::report::ExitClass::Environment,
        );
    };
    apply_with_url(project, &database_url)
}

pub(super) fn apply_if_configured(
    project: &Path,
    configured_url: Option<&str>,
) -> Option<ExitCode> {
    database_url(configured_url).map(|database_url| apply_with_url(project, &database_url))
}

pub(super) fn status(project: &Path, configured_url: Option<&str>) -> ExitCode {
    let Some(database_url) = database_url(configured_url) else {
        return crate::report::fail(
            "AS4107",
            crate::report::ErrorCategory::Configuration,
            "DATABASE_URL is required for migrate status",
            crate::report::ExitClass::Environment,
        );
    };
    match status_project(project, &database_url) {
        Ok(status) => render_status(&status),
        Err(error) => render_error(&error),
    }
}

fn apply_with_url(project: &Path, database_url: &str) -> ExitCode {
    match apply_project(project, database_url) {
        Ok(report) => render_apply(&report),
        Err(error) => render_error(&error),
    }
}

pub(super) fn database_url(configured_url: Option<&str>) -> Option<String> {
    configured_url
        .map(str::to_owned)
        .or_else(|| env::var("DATABASE_URL").ok())
        .filter(|value| !value.trim().is_empty())
}

fn render_apply(report: &ApplyReport) -> ExitCode {
    if matches!(&report.drift, DriftStatus::Detected(_)) {
        return render_drift(&report.drift);
    }
    if crate::report::is_json() {
        crate::report::success(&serde_json::json!({
            "command": "migrate",
            "action": "apply",
            "applied_now": report.applied_now,
            "total_applied": report.total_applied,
            "drift": drift_name(&report.drift),
        }));
    } else {
        println!(
            "Applied {} migration(s); {} total",
            report.applied_now, report.total_applied
        );
    }
    render_drift(&report.drift)
}

fn render_status(status: &MigrationStatus) -> ExitCode {
    if matches!(&status.drift, DriftStatus::Detected(_)) {
        return render_drift(&status.drift);
    }
    if crate::report::is_json() {
        crate::report::success(&serde_json::json!({
            "command": "migrate",
            "action": "status",
            "applied": status.applied,
            "pending": status.pending,
            "drift": drift_name(&status.drift),
        }));
    } else {
        println!("Migration status:");
        println!("- applied: {}", status.applied);
        println!("- pending: {}", status.pending);
    }
    render_drift(&status.drift)
}

pub(super) fn render_drift(drift: &DriftStatus) -> ExitCode {
    match drift {
        DriftStatus::Clean => {
            if !crate::report::is_json() {
                println!("- drift: none");
            }
            ExitCode::SUCCESS
        }
        DriftStatus::Deferred => {
            if !crate::report::is_json() {
                println!("- drift: deferred until pending migrations are applied");
            }
            ExitCode::SUCCESS
        }
        DriftStatus::Detected(issues) => crate::report::fail(
            "AS4111",
            crate::report::ErrorCategory::Database,
            format!("database schema drift detected: {}", issues.join("; ")),
            crate::report::ExitClass::Database,
        ),
    }
}

fn drift_name(drift: &DriftStatus) -> &'static str {
    match drift {
        DriftStatus::Clean => "clean",
        DriftStatus::Deferred => "deferred",
        DriftStatus::Detected(_) => "detected",
    }
}

pub(super) fn render_error(error: &MigrationError) -> ExitCode {
    let (code, exit) = match error {
        MigrationError::Project(_) => ("AS4108", crate::report::ExitClass::Validation),
        MigrationError::Database(_) => ("AS4109", crate::report::ExitClass::Database),
        MigrationError::Integrity(_) => ("AS4110", crate::report::ExitClass::Database),
    };
    crate::report::fail(
        code,
        crate::report::ErrorCategory::Database,
        error.to_string(),
        exit,
    )
}

#[cfg(test)]
mod tests {
    use super::*;
    use appstruct_migrate::{ApplyReport, DriftStatus, MigrationStatus};

    #[test]
    fn empty_configured_urls_are_treated_as_missing() {
        assert!(database_url(Some("")).is_none());
        assert!(database_url(Some("   ")).is_none());
        assert_eq!(
            database_url(Some("postgresql://localhost/appstruct")).as_deref(),
            Some("postgresql://localhost/appstruct")
        );
    }

    #[test]
    fn render_helpers_cover_clean_deferred_and_detected_drift() {
        crate::report::set_output_format(crate::report::OutputFormat::Text);
        assert_eq!(
            render_status(&MigrationStatus {
                applied: 1,
                pending: 0,
                drift: DriftStatus::Clean,
            }),
            ExitCode::SUCCESS
        );
        assert_eq!(
            render_status(&MigrationStatus {
                applied: 1,
                pending: 2,
                drift: DriftStatus::Deferred,
            }),
            ExitCode::SUCCESS
        );
        assert_ne!(
            render_status(&MigrationStatus {
                applied: 1,
                pending: 0,
                drift: DriftStatus::Detected(vec!["missing table".to_owned()]),
            }),
            ExitCode::SUCCESS
        );
        assert_eq!(
            render_apply(&ApplyReport {
                applied_now: 1,
                total_applied: 2,
                drift: DriftStatus::Clean,
            }),
            ExitCode::SUCCESS
        );
        crate::report::set_output_format(crate::report::OutputFormat::Json);
        assert_eq!(
            render_status(&MigrationStatus {
                applied: 0,
                pending: 1,
                drift: DriftStatus::Deferred,
            }),
            ExitCode::SUCCESS
        );
        assert_eq!(
            render_apply(&ApplyReport {
                applied_now: 0,
                total_applied: 1,
                drift: DriftStatus::Clean,
            }),
            ExitCode::SUCCESS
        );
        crate::report::set_output_format(crate::report::OutputFormat::Text);
        assert_ne!(
            render_error(&MigrationError::Project("bad project".to_owned())),
            ExitCode::SUCCESS
        );
        assert_ne!(
            render_error(&MigrationError::Database("bad db".to_owned())),
            ExitCode::SUCCESS
        );
        assert_ne!(
            render_error(&MigrationError::Integrity("bad history".to_owned())),
            ExitCode::SUCCESS
        );
        assert_eq!(drift_name(&DriftStatus::Clean), "clean");
        assert_eq!(drift_name(&DriftStatus::Deferred), "deferred");
        assert_eq!(drift_name(&DriftStatus::Detected(Vec::new())), "detected");
    }

    #[test]
    fn apply_if_configured_skips_blank_urls_and_connects_with_explicit_ones() {
        let project = tempfile::tempdir().unwrap();
        assert!(apply_if_configured(project.path(), Some("")).is_none());
        let code = apply_if_configured(
            project.path(),
            Some("postgresql://appstruct:secret@127.0.0.1:1/appstruct?sslmode=disable"),
        );
        assert!(code.is_some());
        assert_ne!(code.unwrap(), ExitCode::SUCCESS);
    }
}