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

use super::{Auth, Client};
use reqwest::Url;
use thiserror::Error;

#[derive(Debug, Error)]
pub enum BuildError {
    #[error("{0}")]
    ReqwestError(#[from] reqwest::Error),
    #[error("couldn't parse base url")]
    UrlParseError,
}

#[derive(Default)]
pub struct ClientBuilder {
    auth: Option<Auth>,
    client: Option<reqwest::blocking::Client>,
    user_agent: Option<String>,
    base_url: Option<Url>,
}

impl ClientBuilder {
    #[must_use]
    pub fn new() -> Self {
        Self::default()
    }

    pub fn build(self) -> Result<Client, BuildError> {
        let client = if let Some(client) = self.client {
            client
        } else {
            reqwest::blocking::Client::builder()
                .user_agent(self.user_agent.unwrap_or_else(|| String::from("Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/117.0.0.0 Mobile Safari/537.3")))
                .build()?
        };

        let url_base = if let Some(url_base) = self.base_url {
            url_base
        } else if let Ok(url_base) = Url::parse("https://api.discogs.com") {
            url_base
        } else {
            return Err(BuildError::UrlParseError);
        };

        Ok(Client {
            client,
            auth: self.auth,
            url_base,
        })
    }

    #[must_use]
    pub fn auth(mut self, auth: Auth) -> Self {
        self.auth = Some(auth);
        self
    }

    #[must_use]
    pub fn client(mut self, client: reqwest::blocking::Client) -> Self {
        self.client = Some(client);
        self
    }

    #[must_use]
    pub fn user_agent(mut self, user_agent: String) -> Self {
        self.user_agent = Some(user_agent);
        self
    }
}