railwayapp 3.0.19

Interact with Railway via 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

use serde::Serialize;

use super::{
    queries::{
        projects::ProjectsProjectsEdgesNode, user_projects::UserProjectsMeProjectsEdgesNode,
    },
    *,
};

/// List all projects in your Railway account
#[derive(Parser)]
pub struct Args {}

pub async fn command(_args: Args, json: bool) -> Result<()> {
    let configs = Configs::new()?;
    let client = GQLClient::new_authorized(&configs)?;
    let linked_project = configs.get_linked_project().await.ok();

    let vars = queries::user_projects::Variables {};
    let res =
        post_graphql::<queries::UserProjects, _>(&client, configs.get_backboard(), vars).await?;
    let body = res.data.context("Failed to get user (query me)")?;

    let mut personal_projects: Vec<_> = body
        .me
        .projects
        .edges
        .iter()
        .map(|project| &project.node)
        .collect();
    // Sort by most recently updated (matches dashboard behavior)
    personal_projects.sort_by(|a, b| b.updated_at.cmp(&a.updated_at));

    let mut all_projects: Vec<_> = personal_projects
        .iter()
        .map(|project| Project::Me((*project).clone()))
        .collect();

    let teams: Vec<_> = body.me.teams.edges.iter().map(|team| &team.node).collect();
    if !json {
        println!("{}", "Personal".bold());
        for project in &personal_projects {
            let project_name = if linked_project.is_some()
                && project.id == linked_project.as_ref().unwrap().project
            {
                project.name.purple().bold()
            } else {
                project.name.white()
            };
            println!("  {project_name}");
        }
    }

    for team in teams {
        if !json {
            println!();
            println!("{}", team.name.bold());
        }
        {
            let vars = queries::projects::Variables {
                team_id: Some(team.id.clone()),
            };

            let res = post_graphql::<queries::Projects, _>(&client, configs.get_backboard(), vars)
                .await?;

            let body = res.data.context("Failed to retrieve response body")?;
            let mut projects: Vec<_> = body
                .projects
                .edges
                .iter()
                .map(|project| &project.node)
                .collect();
            projects.sort_by(|a, b| a.updated_at.cmp(&b.updated_at));
            let mut team_projects: Vec<_> = projects
                .iter()
                .map(|project| Project::Team((*project).clone()))
                .collect();
            all_projects.append(&mut team_projects);
            if !json {
                for project in &projects {
                    let project_name = if linked_project.is_some()
                        && project.id == linked_project.as_ref().unwrap().project
                    {
                        project.name.purple().bold()
                    } else {
                        project.name.white()
                    };
                    println!("  {project_name}");
                }
            }
        }
    }
    if json {
        println!("{}", serde_json::to_string_pretty(&all_projects)?);
    }
    Ok(())
}

#[derive(Debug, Clone, Serialize)]
#[serde(untagged)]
enum Project {
    Me(UserProjectsMeProjectsEdgesNode),
    Team(ProjectsProjectsEdgesNode),
}