krabdex 0.1.0

A type-safe, async Rust SDK for the PokeAPI
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

use ::url::Url;

use crate::{
    client::{config::ClientConfig, client::PokeApiClient},
    error::{Error, Result},
    transport::reqwest_transport::ReqwestTransport
};

/// Builder for constructing a `PokeApiClient` with custom settings.
#[derive(Debug)]
pub struct PokeApiClientBuilder {
    config: ClientConfig,
    timeout: Option<std::time::Duration>,
    user_agent: Option<String>,
}

impl Default for PokeApiClientBuilder {
    fn default() -> Self {
        Self {
            config: ClientConfig::default(),
            timeout: Some(std::time::Duration::from_secs(10)),
            user_agent: Some("krabdex/0.1.0".to_string()),
        }
    }
}

impl PokeApiClientBuilder {
    /// Create a builder with default configuration.
    pub fn new() -> Self {
        Self::default()
    }

    /// Start a builder from an existing `ClientConfig`.
    pub fn from_config(config: ClientConfig) -> Self {
        Self {
            config,
            timeout: Some(std::time::Duration::from_secs(10)),
            user_agent: Some("krabdex/0.1.0".to_string()),
        }
    }

    /// Override the base URL (defaults to `https://pokeapi.co/`).
    pub fn base_url(mut self, url: Url) -> Self {
        self.config.base_url = url;
        self
    }

    /// Override the API prefix (defaults to `api/v2`).
    pub fn api_prefix(mut self, prefix: impl Into<String>) -> Self {
        self.config.api_prefix = prefix.into();
        self
    }

    /// Add or override a default header applied to every request.
    pub fn default_header(mut self, key: impl Into<String>, value: impl Into<String>) -> Self {
        self.config.default_headers.insert(key, value);
        self
    }

    /// Set a client-wide timeout.
    pub fn timeout(mut self, d: std::time::Duration) -> Self {
        self.timeout = Some(d);
        self
    }

    /// Set the User-Agent header for all requests.
    pub fn user_agent(mut self, ua: impl Into<String>) -> Self {
        self.user_agent = Some(ua.into());
        self
    }

    /// Build a `PokeApiClient` from the accumulated configuration.
    pub fn build(self) -> Result<PokeApiClient> {
        let mut rb = reqwest::Client::builder();

        if let Some(t) = self.timeout {
            rb = rb.timeout(t);
        }
        if let Some(ua) = &self.user_agent {
            rb = rb.user_agent(ua.clone());
        }

        let client = rb
            .build()
            .map_err(|e| Error::Transport { source: Box::new(e) })?;

        let transport = ReqwestTransport::new(client);

        Ok(PokeApiClient {
            config: self.config,
            transport,
        })
    }
}