email-cli 0.6.1

Agent-friendly email CLI for Resend
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

use anyhow::{Context, Result};

use crate::app::App;
use crate::cli::*;
use crate::models::*;
use crate::output::print_success_or;

impl App {
    /// Get the API client for the first (or only) profile.
    /// Domain/contact/segment/topic/broadcast/api-key commands are profile-level.
    pub fn default_client(&self) -> Result<crate::resend::ResendClient> {
        let name: String = self.conn.query_row(
            "SELECT name FROM profiles ORDER BY name LIMIT 1",
            [],
            |row| row.get(0),
        ).context("no profiles configured \u{2014} run: email-cli profile add")?;
        self.client_for_profile(&name)
    }

    pub fn domain_list(&self) -> Result<()> {
        let client = self.default_client()?;
        let domains = client.list_domains()?;
        print_success_or(self.format, &domains, |d| {
            for domain in &d.data {
                let status = domain.status.as_deref().unwrap_or("unknown");
                println!("{} status={}", domain.name, status);
            }
        });
        Ok(())
    }

    pub fn domain_get(&self, args: DomainGetArgs) -> Result<()> {
        let client = self.default_client()?;
        let domain = client.get_domain(&args.id)?;
        print_success_or(self.format, &domain, |d| {
            println!("id: {}", d.id);
            println!("name: {}", d.name);
            println!("status: {}", d.status.as_deref().unwrap_or("unknown"));
            if !d.records.is_empty() {
                println!("records:");
                for record in &d.records {
                    let rtype = record.record_type.as_deref().unwrap_or("?");
                    let name = record.name.as_deref().unwrap_or("?");
                    let value = record.value.as_deref().unwrap_or("?");
                    let status = record.status.as_deref().unwrap_or("?");
                    println!("  {} {} {} ({})", rtype, name, value, status);
                }
            }
        });
        Ok(())
    }

    pub fn domain_create(&self, args: DomainCreateArgs) -> Result<()> {
        let client = self.default_client()?;
        let response = client.create_domain(&CreateDomainRequest {
            name: args.name,
            region: args.region,
        })?;
        print_success_or(self.format, &response, |r| {
            println!("created domain {} (id: {})", r.name, r.id);
        });
        Ok(())
    }

    pub fn domain_verify(&self, args: DomainVerifyArgs) -> Result<()> {
        let client = self.default_client()?;
        let domain = client.verify_domain(&args.id)?;
        print_success_or(self.format, &domain, |d| {
            println!("verified {} status={}", d.name, d.status.as_deref().unwrap_or("unknown"));
        });
        Ok(())
    }

    pub fn domain_delete(&self, args: DomainDeleteArgs) -> Result<()> {
        let client = self.default_client()?;
        let response = client.delete_domain(&args.id)?;
        print_success_or(self.format, &response, |r| {
            println!("deleted: {}", r.deleted);
        });
        Ok(())
    }

    pub fn domain_update(&self, args: DomainUpdateArgs) -> Result<()> {
        let client = self.default_client()?;
        let domain = client.update_domain(&args.id, &UpdateDomainRequest {
            open_tracking: args.open_tracking,
            click_tracking: args.click_tracking,
        })?;
        print_success_or(self.format, &domain, |d| {
            println!("updated {} status={}", d.name, d.status.as_deref().unwrap_or("unknown"));
        });
        Ok(())
    }
}