invoice-cli 0.5.13

Beautiful invoices from the CLI — international, stateful, agent-friendly
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

use crate::cli::ConfigCmd;
use crate::config;
use crate::error::{AppError, Result};
use crate::output::{print_success, Ctx};

pub fn run(cmd: ConfigCmd, ctx: Ctx) -> Result<()> {
    match cmd {
        ConfigCmd::Show => {
            let cfg = config::load()?;
            print_success(ctx, &cfg, |c| println!("{:#?}", c));
            Ok(())
        }
        ConfigCmd::Path => {
            let p = config::config_path()?;
            print_success(ctx, &p, |p| println!("{}", p.display()));
            Ok(())
        }
        ConfigCmd::Set { key, value } => {
            let remove_key = matches!(
                value.to_ascii_lowercase().as_str(),
                "unset" | "none" | "null" | ""
            );
            validate_config_value(&key, &value, remove_key)?;

            // Minimal implementation: set-and-save via toml::Value merge.
            let path = config::config_path()?;
            let existing = if path.exists() {
                std::fs::read_to_string(&path)?
            } else {
                String::new()
            };
            let mut doc: toml::Value =
                toml::from_str(&existing).unwrap_or(toml::Value::Table(Default::default()));
            if let toml::Value::Table(ref mut t) = doc {
                if remove_key {
                    t.remove(&key);
                } else {
                    t.insert(key.clone(), parse_value(&value));
                }
            } else {
                return Err(AppError::Config("config root is not a table".into()));
            }
            std::fs::write(&path, toml::to_string_pretty(&doc).unwrap())?;
            print_success(
                ctx,
                &serde_json::json!({"key": key, "value": if remove_key { serde_json::Value::Null } else { serde_json::Value::String(value.clone()) }}),
                |_| {
                    if remove_key {
                        println!("unset {key}");
                    } else {
                        println!("set {key} = {value}");
                    }
                },
            );
            Ok(())
        }
    }
}

fn validate_config_value(key: &str, value: &str, remove_key: bool) -> Result<()> {
    if key == "default_issuer" && !remove_key {
        let conn = crate::db::open()?;
        crate::db::issuer_by_slug(&conn, value).map_err(|_| {
            AppError::InvalidInput(format!(
                "unknown issuer '{value}' for config.default_issuer. Add it first or run `invoice issuer list`."
            ))
        })?;
    }
    Ok(())
}

fn parse_value(v: &str) -> toml::Value {
    if v == "true" {
        toml::Value::Boolean(true)
    } else if v == "false" {
        toml::Value::Boolean(false)
    } else if let Ok(n) = v.parse::<i64>() {
        toml::Value::Integer(n)
    } else {
        toml::Value::String(v.to_string())
    }
}