syncable-cli 0.37.1

A Rust-based CLI that analyzes code repositories and generates Infrastructure as Code configurations
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

//! Cluster selection step for deployment wizard

use crate::platform::api::types::ClusterSummary;
use crate::wizard::render::{display_step_header, status_indicator, wizard_render_config};
use colored::Colorize;
use inquire::{InquireError, Select};

/// Result of cluster selection step
#[derive(Debug, Clone)]
pub enum ClusterSelectionResult {
    /// User selected a cluster
    Selected(ClusterSummary),
    /// User wants to go back
    Back,
    /// User cancelled the wizard
    Cancelled,
}

/// Display cluster selection for Kubernetes deployments
pub fn select_cluster(clusters: &[ClusterSummary]) -> ClusterSelectionResult {
    display_step_header(
        3,
        "Select Cluster",
        "Choose which Kubernetes cluster to deploy to.",
    );

    // Filter to only healthy clusters
    let healthy_clusters: Vec<&ClusterSummary> = clusters.iter().filter(|c| c.is_healthy).collect();

    if healthy_clusters.is_empty() {
        println!(
            "\n{}",
            "No healthy clusters available. Provision a cluster in platform settings.".red()
        );
        return ClusterSelectionResult::Cancelled;
    }

    // Build options with status and region
    let mut options: Vec<String> = healthy_clusters
        .iter()
        .map(|c| {
            format!(
                "{} {}  {}",
                status_indicator(c.is_healthy),
                c.name.cyan(),
                c.region.dimmed()
            )
        })
        .collect();

    // Add back option
    options.push("← Back to target selection".dimmed().to_string());

    let selection = Select::new("Select cluster:", options.clone())
        .with_render_config(wizard_render_config())
        .with_help_message("↑↓ to move, Enter to select, Esc to cancel")
        .with_page_size(6)
        .prompt();

    match selection {
        Ok(answer) => {
            if answer.contains("Back") {
                return ClusterSelectionResult::Back;
            }

            // Find selected cluster by name
            let selected = healthy_clusters
                .iter()
                .find(|c| answer.contains(&c.name))
                .copied();

            match selected {
                Some(cluster) => {
                    println!(
                        "\n{} Selected cluster: {} ({})",
                        "✓".green(),
                        cluster.name,
                        cluster.region
                    );
                    ClusterSelectionResult::Selected(cluster.clone())
                }
                None => ClusterSelectionResult::Cancelled,
            }
        }
        Err(InquireError::OperationCanceled) | Err(InquireError::OperationInterrupted) => {
            println!("\n{}", "Wizard cancelled.".dimmed());
            ClusterSelectionResult::Cancelled
        }
        Err(_) => ClusterSelectionResult::Cancelled,
    }
}

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

    #[test]
    fn test_cluster_selection_result_variants() {
        let cluster = ClusterSummary {
            id: "c1".to_string(),
            name: "prod".to_string(),
            region: "us-central1".to_string(),
            is_healthy: true,
        };
        let _ = ClusterSelectionResult::Selected(cluster);
        let _ = ClusterSelectionResult::Back;
        let _ = ClusterSelectionResult::Cancelled;
    }
}