nxthdr 0.2.0

Command line interface for the nxthdr 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

use anyhow::{Context, Result};
use serde::de::DeserializeOwned;
use std::time::{SystemTime, UNIX_EPOCH};

use crate::config;

const DEFAULT_API_BASE_URL: &str = "https://peerlab.nxthdr.dev";

pub struct ApiClient {
    base_url: String,
    client: reqwest::Client,
}

impl ApiClient {
    pub fn new() -> Self {
        let base_url =
            std::env::var("NXTHDR_API_URL").unwrap_or_else(|_| DEFAULT_API_BASE_URL.to_string());

        Self {
            base_url,
            client: reqwest::Client::new(),
        }
    }

    async fn get_valid_token(&self) -> Result<String> {
        let tokens =
            config::load_tokens().context("Not logged in. Please run 'nxthdr login' first.")?;

        let now = SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .unwrap()
            .as_secs() as i64;

        if tokens.expires_at < now {
            config::delete_tokens()?;
            anyhow::bail!("Access token expired. Please run 'nxthdr login' again.");
        }

        Ok(tokens.access_token)
    }

    pub async fn get<T: DeserializeOwned>(&self, path: &str) -> Result<T> {
        let token = self.get_valid_token().await?;
        let url = format!("{}{}", self.base_url, path);

        tracing::debug!("GET {}", url);

        let response = self
            .client
            .get(&url)
            .bearer_auth(&token)
            .send()
            .await
            .context("Failed to send request")?;

        let status = response.status();

        if !status.is_success() {
            let error_body = response.text().await.unwrap_or_default();
            anyhow::bail!("API request failed with status {}: {}", status, error_body);
        }

        let data = response
            .json::<T>()
            .await
            .context("Failed to parse response")?;

        Ok(data)
    }

    pub async fn post<T: DeserializeOwned, B: serde::Serialize>(
        &self,
        path: &str,
        body: &B,
    ) -> Result<T> {
        let token = self.get_valid_token().await?;
        let url = format!("{}{}", self.base_url, path);

        tracing::debug!("POST {}", url);

        let response = self
            .client
            .post(&url)
            .bearer_auth(&token)
            .json(body)
            .send()
            .await
            .context("Failed to send request")?;

        let status = response.status();

        if !status.is_success() {
            let error_body = response.text().await.unwrap_or_default();
            anyhow::bail!("API request failed with status {}: {}", status, error_body);
        }

        let data = response
            .json::<T>()
            .await
            .context("Failed to parse response")?;

        Ok(data)
    }

    pub async fn delete(&self, path: &str) -> Result<()> {
        let token = self.get_valid_token().await?;
        let url = format!("{}{}", self.base_url, path);

        tracing::debug!("DELETE {}", url);

        let response = self
            .client
            .delete(&url)
            .bearer_auth(&token)
            .send()
            .await
            .context("Failed to send request")?;

        let status = response.status();

        if !status.is_success() {
            let error_body = response.text().await.unwrap_or_default();
            anyhow::bail!("API request failed with status {}: {}", status, error_body);
        }

        Ok(())
    }
}