notra 0.1.1

Unofficial Rust SDK for the Notra API
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
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
130
131
132
133
134
135

use std::time::Duration;

use reqwest::header::{HeaderMap, HeaderValue, AUTHORIZATION, CONTENT_TYPE};
use serde::de::DeserializeOwned;
use serde::Serialize;

use crate::content::Content;
use crate::error::{ErrorResponse, NotraError, Result};

const DEFAULT_BASE_URL: &str = "https://api.usenotra.com";
const DEFAULT_TIMEOUT_SECS: u64 = 30;

pub struct Notra {
    pub(crate) http: reqwest::Client,
    pub(crate) base_url: String,
}

impl Notra {
    pub fn builder() -> NotraBuilder {
        NotraBuilder::default()
    }

    pub fn content(&self) -> Content<'_> {
        Content::new(self)
    }

    pub(crate) async fn get<T: DeserializeOwned>(
        &self,
        path: &str,
        query: &[(&str, String)],
    ) -> Result<T> {
        let url = format!("{}{}", self.base_url, path);
        let resp = self.http.get(&url).query(query).send().await?;
        self.handle_response(resp).await
    }

    pub(crate) async fn post<T: DeserializeOwned, B: Serialize>(
        &self,
        path: &str,
        body: &B,
    ) -> Result<T> {
        let url = format!("{}{}", self.base_url, path);
        let resp = self.http.post(&url).json(body).send().await?;
        self.handle_response(resp).await
    }

    pub(crate) async fn patch<T: DeserializeOwned, B: Serialize>(
        &self,
        path: &str,
        body: &B,
    ) -> Result<T> {
        let url = format!("{}{}", self.base_url, path);
        let resp = self.http.patch(&url).json(body).send().await?;
        self.handle_response(resp).await
    }

    pub(crate) async fn delete<T: DeserializeOwned>(&self, path: &str) -> Result<T> {
        let url = format!("{}{}", self.base_url, path);
        let resp = self.http.delete(&url).send().await?;
        self.handle_response(resp).await
    }

    async fn handle_response<T: DeserializeOwned>(
        &self,
        resp: reqwest::Response,
    ) -> Result<T> {
        let status = resp.status();
        if status.is_success() {
            Ok(resp.json().await?)
        } else {
            let body = resp.text().await.unwrap_or_default();
            let message = serde_json::from_str::<ErrorResponse>(&body)
                .ok()
                .and_then(|e| e.message)
                .unwrap_or(body);
            Err(NotraError::Api {
                status: status.as_u16(),
                message,
            })
        }
    }
}

#[derive(Default)]
pub struct NotraBuilder {
    bearer_auth: Option<String>,
    server_url: Option<String>,
    timeout: Option<Duration>,
}

impl NotraBuilder {
    pub fn bearer_auth(mut self, token: impl Into<String>) -> Self {
        self.bearer_auth = Some(token.into());
        self
    }

    pub fn server_url(mut self, url: impl Into<String>) -> Self {
        self.server_url = Some(url.into());
        self
    }

    pub fn timeout(mut self, timeout: Duration) -> Self {
        self.timeout = Some(timeout);
        self
    }

    pub fn build(self) -> Result<Notra> {
        let token = self
            .bearer_auth
            .ok_or_else(|| NotraError::Builder("bearer_auth is required".into()))?;

        let mut headers = HeaderMap::new();
        let auth_value = format!("Bearer {}", token);
        headers.insert(
            AUTHORIZATION,
            HeaderValue::from_str(&auth_value)
                .map_err(|e| NotraError::Builder(format!("invalid auth token: {e}")))?,
        );
        headers.insert(CONTENT_TYPE, HeaderValue::from_static("application/json"));

        let timeout = self.timeout.unwrap_or(Duration::from_secs(DEFAULT_TIMEOUT_SECS));

        let http = reqwest::Client::builder()
            .default_headers(headers)
            .timeout(timeout)
            .build()
            .map_err(|e| NotraError::Builder(format!("failed to build HTTP client: {e}")))?;

        let base_url = self
            .server_url
            .unwrap_or_else(|| DEFAULT_BASE_URL.to_string());

        Ok(Notra { http, base_url })
    }
}