plaid 9.0.1

Plaid client, generated from the OpenAPI spec.
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

// libninja: static
use httpclient::Client;
use std::borrow::Cow;
use std::env::var;
use std::sync::OnceLock;
pub mod model;
pub mod request;
pub fn default_http_client() -> Client {
    Client::new().base_url(
        std::env::var("PLAID_ENV")
            .expect("Missing environment variable PLAID_ENV")
            .as_str(),
    )
}
static SHARED_HTTPCLIENT: OnceLock<Client> = OnceLock::new();
/// Use this method if you want to add custom middleware to the httpclient.
/// It must be called before any requests are made, otherwise it will have no effect.
/// Example usage:
///
/// ```
/// init_http_client(default_http_client()
///     .with_middleware(..)
/// );
/// ```
pub fn init_http_client(init: Client) {
    let _ = SHARED_HTTPCLIENT.set(init);
}
fn shared_http_client() -> Cow<'static, Client> {
    Cow::Borrowed(SHARED_HTTPCLIENT.get_or_init(default_http_client))
}
#[derive(Clone)]
pub struct FluentRequest<'a, T> {
    pub(crate) client: &'a PlaidClient,
    pub params: T,
}
pub struct PlaidClient {
    client: Cow<'static, Client>,
    authentication: PlaidAuth,
}
impl PlaidClient {
    pub fn from_env() -> Self {
        Self {
            client: shared_http_client(),
            authentication: PlaidAuth::from_env(),
        }
    }
    pub fn with_auth(authentication: PlaidAuth) -> Self {
        Self {
            client: shared_http_client(),
            authentication,
        }
    }
    pub fn new(client: Client, authentication: PlaidAuth) -> Self {
        Self {
            client: Cow::Owned(client),
            authentication,
        }
    }
}
impl PlaidClient {
    pub(crate) fn authenticate<'a>(
        &self,
        mut r: httpclient::RequestBuilder<'a>,
    ) -> httpclient::RequestBuilder<'a> {
        match &self.authentication {
            PlaidAuth::ClientId {
                client_id,
                secret,
                version,
            } => {
                r = r.header("PLAID-CLIENT-ID", client_id);
                r = r.header("PLAID-SECRET", secret);
                r = r.header("Plaid-Version", version);
            }
        }
        r
    }
}
pub enum PlaidAuth {
    ClientId {
        client_id: String,
        secret: String,
        version: String,
    },
}

impl PlaidAuth {
    pub fn from_env() -> Self {
        Self::ClientId {
            client_id: var("PLAID_CLIENT_ID").expect("env var PLAID_CLIENT_ID is not set"),
            secret: var("PLAID_SECRET").expect("env var PLAID_SECRET is not set"),
            version: var("PLAID_VERSION").expect("env var PLAID_VERSION is not set"),
        }
    }
}