flexprice-cli 0.1.1

A beautiful terminal CLI for the FlexPrice billing platform
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

use anyhow::Result;
use clap::Subcommand;
use tabled::Tabled;

use crate::api::client::ApiClient;
use crate::api::models::{Customer, ListResponse};
use crate::cli::auth::require_auth;
use crate::utils::{output, spinner};

#[derive(Subcommand)]
pub enum CustomerCommands {
    /// List all customers
    List {
        /// Output as JSON
        #[arg(long)]
        json: bool,
    },
    /// Get a customer by ID
    Get {
        /// Customer ID
        id: String,
        /// Output as JSON
        #[arg(long)]
        json: bool,
    },
    /// Create a new customer from a JSON file
    Create {
        /// Path to JSON file with customer data
        #[arg(long)]
        json: String,
    },
    /// Delete a customer by ID
    Delete {
        /// Customer ID
        id: String,
    },
    /// View customer usage summary
    Usage {
        /// Customer ID
        id: String,
        /// Output as JSON
        #[arg(long)]
        json: bool,
    },
    /// View customer entitlements
    Entitlements {
        /// Customer ID
        id: String,
        /// Output as JSON
        #[arg(long)]
        json: bool,
    },
}

#[derive(Tabled, serde::Serialize)]
struct CustomerRow {
    #[tabled(rename = "ID")]
    id: String,
    #[tabled(rename = "Name")]
    name: String,
    #[tabled(rename = "Email")]
    email: String,
    #[tabled(rename = "External ID")]
    external_id: String,
    #[tabled(rename = "Status")]
    status: String,
}

impl From<Customer> for CustomerRow {
    fn from(c: Customer) -> Self {
        Self {
            id: c.id,
            name: c.name.unwrap_or_default(),
            email: c.email.unwrap_or_default(),
            external_id: c.external_id.unwrap_or_default(),
            status: c.status.map(|s| output::status_badge(&s)).unwrap_or_default(),
        }
    }
}

pub async fn handle(cmd: CustomerCommands) -> Result<()> {
    let creds = require_auth()?;
    let client = ApiClient::new(creds)?;

    match cmd {
        CustomerCommands::List { json } => {
            let sp = spinner::create_spinner("Fetching customers...");
            let resp: ListResponse<Customer> = client.get("/v1/customers").await?;
            sp.finish_and_clear();

            let rows: Vec<CustomerRow> = resp.items.into_iter().map(Into::into).collect();
            println!("{}", output::print_table(&rows, json));
        }
        CustomerCommands::Get { id, json } => {
            let sp = spinner::create_spinner("Fetching customer...");
            let customer: Customer = client.get(&format!("/v1/customers/{}", id)).await?;
            sp.finish_and_clear();
            println!("{}", output::print_detail(&customer, json));
        }
        CustomerCommands::Create { json: file } => {
            let data = std::fs::read_to_string(&file)?;
            let body: serde_json::Value = serde_json::from_str(&data)?;
            let sp = spinner::create_spinner("Creating customer...");
            let customer: Customer = client.post("/v1/customers", &body).await?;
            sp.finish_and_clear();
            output::success(&format!("Customer created: {}", customer.id));
            println!("{}", output::print_detail(&customer, false));
        }
        CustomerCommands::Delete { id } => {
            let sp = spinner::create_spinner("Deleting customer...");
            client.delete_empty(&format!("/v1/customers/{}", id)).await?;
            sp.finish_and_clear();
            output::success(&format!("Customer {} deleted.", id));
        }
        CustomerCommands::Usage { id, json } => {
            let sp = spinner::create_spinner("Fetching usage...");
            let usage: serde_json::Value = client.get(&format!("/v1/customers/{}/usage", id)).await?;
            sp.finish_and_clear();
            println!("{}", output::print_detail(&usage, json));
        }
        CustomerCommands::Entitlements { id, json } => {
            let sp = spinner::create_spinner("Fetching entitlements...");
            let ents: serde_json::Value = client.get(&format!("/v1/customers/{}/entitlements", id)).await?;
            sp.finish_and_clear();
            println!("{}", output::print_detail(&ents, json));
        }
    }
    Ok(())
}