frakti 0.1.3

Telegram bot API client for Rust, with a focus on single-threaded async runtime support
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

use std::{fmt::Debug, path::PathBuf};

use bon::Builder;
use compio::fs::File;
use cyper::{
    multipart::{Form, Part},
    Client, Error as CyperError, Response,
};
use serde::{de::DeserializeOwned, Serialize};

use super::{json::encode_object, trait_async::AsyncTelegramApi, Error, BASE_API_URL};

/// Asynchronous [`AsyncTelegramApi`] implementation with [`cyper`]
#[derive(Debug, Clone, Builder)]
#[must_use = "Bot needs to be used in order to be useful"]
pub struct Bot {
    #[builder(into)]
    pub api_url: String,

    #[builder(default = Client::new().expect("Failed to create HTTP client"))]
    pub client: Client,
}

impl Bot {
    /// Create a new `Bot`. You can use [`Bot::new_url`] or [`Bot::builder`] for more options.
    pub fn new(api_key: &str) -> Self {
        Self::new_url(format!("{BASE_API_URL}{api_key}"))
    }

    /// Create a new `Bot`. You can use [`Bot::builder`] for more options.
    pub fn new_url<S: Into<String>>(api_url: S) -> Self {
        Self::builder().api_url(api_url).build()
    }

    async fn decode_response<Output>(response: Response) -> Result<Output, Error>
    where
        Output: DeserializeOwned,
    {
        let success = response.status().is_success();
        if success {
            Ok(response.json().await?)
        } else {
            Err(Error::Api(response.json().await?))
        }
    }
}

impl From<CyperError> for Error {
    fn from(error: CyperError) -> Self {
        Self::HttpCyper(error)
    }
}

impl AsyncTelegramApi for Bot {
    type Error = Error;

    async fn request<Params, Output>(
        &self,
        method: &str,
        params: Option<Params>,
    ) -> Result<Output, Self::Error>
    where
        Params: Serialize + Debug + Send,
        Output: DeserializeOwned,
    {
        let url = format!("{}/{method}", self.api_url);
        let mut prepared_request = self
            .client
            .post(url)?
            .header("Content-Type", "application/json")?;
        if let Some(params) = params {
            prepared_request = prepared_request.json(&params)?;
        }
        let response = prepared_request.send().await?;
        Self::decode_response(response).await
    }

    async fn request_with_form_data<Params, Output>(
        &self,
        method: &str,
        params: Params,
        files: Vec<(&str, PathBuf)>,
    ) -> Result<Output, Self::Error>
    where
        Params: Serialize + Debug + Send,
        Output: DeserializeOwned,
    {
        let json_struct = encode_object(&params)?;
        let file_keys: Vec<&str> = files.iter().map(|(key, _)| *key).collect();

        let mut form = Form::new();
        for (key, val) in json_struct {
            if !file_keys.contains(&key.as_str()) {
                form = match val {
                    serde_json::Value::String(val) => form.text(key, val),
                    other => form.text(key, other.to_string()),
                };
            }
        }

        for (parameter_name, file_path) in files {
            let file = File::open(&file_path).await.map_err(Error::ReadFile)?;
            let file_name = file_path.file_name().unwrap().to_string_lossy().to_string();
            let part = Part::stream(file).file_name(file_name);
            form = form.part(parameter_name.to_owned(), part);
        }

        let url = format!("{}/{method}", self.api_url);

        let response = self.client.post(url)?.multipart(form)?.send().await?;
        Self::decode_response(response).await
    }
}