feat: send files directly from bytes

Cargo.toml

@@ -19,7 +19,7 @@ categories = ["web-programming::http-client"]
 all-features = true
 
 [features]
-client-reqwest = ["trait-async", "dep:reqwest", "dep:tokio", "dep:serde_json"]
+client-reqwest = ["trait-async", "dep:reqwest", "dep:serde_json"]
 client-ureq = ["trait-sync", "dep:ureq", "dep:multipart", "dep:mime_guess", "dep:serde_json"]
 trait-async = ["dep:async-trait"]
 trait-sync = []
@@ -59,11 +59,6 @@ default-features = false
 features = ["multipart", "stream"]
 optional = true
 
-[target.'cfg(not(target_arch = "wasm32"))'.dependencies.tokio]
-version = "1"
-features = ["fs"]
-optional = true
-
 [dev-dependencies]
 isahc = "1"
 mockito = "1.0"
@@ -86,6 +81,10 @@ required-features = ["client-ureq"]
 name = "inline_keyboard"
 required-features = ["client-ureq"]
 
+[[example]]
+name = "file_upload"
+required-features = ["client-ureq"]
+
 [[example]]
 name = "custom_client"
 required-features = ["client-ureq"]

README.md

@@ -27,7 +27,7 @@ Without enabling any additional features this crate will only ship with Telegram
   - `client-ureq` - a blocking HTTP API client based on `ureq`
   - `trait-sync` - a blocking API trait, it's included in the `client-ureq` feature. It may be useful for people who want to create a custom blocking client (for example, replacing an HTTP client)
 - async
-  - `client-reqwest` - an async HTTP API client based on `reqwest`. This client partially supports wasm32, but file uploads are currently not supported there.
+  - `client-reqwest` - an async HTTP API client based on `reqwest`. This client supports wasm32
   - `trait-async` - an async API trait, it's used in the `client-reqwest`. It may be useful for people who want to create a custom async client
 
 For example for the async client add the following line to your `Cargo.toml` file:
@@ -114,26 +114,6 @@ Every function returns a `Result` with a successful response or failed response.
 
 See more examples in the [`examples`](https://github.com/ayrat555/frankenstein/tree/0.40.2/examples) directory.
 
-### Uploading files
-
-Some methods in the API allow uploading files. In the Frankenstein for this `FileUpload` enum is used:
-
-```rust
-pub enum FileUpload {
-    InputFile(InputFile),
-    String(String),
-}
-
-pub struct InputFile {
-    path: std::path::PathBuf
-}
-```
-
-It has two variants:
-
-- `FileUpload::String` is used to pass the ID of the already uploaded file
-- `FileUpload::InputFile` is used to upload a new file using multipart upload.
-
 ### Documentation
 
 Frankenstein implements all Telegram bot API methods. To see which parameters you should pass, check the [official Telegram Bot API documentation](https://core.telegram.org/bots/api#available-methods) or [docs.rs/frankenstein](https://docs.rs/frankenstein/0.40.0/frankenstein/trait.TelegramApi.html#provided-methods)

examples/api_trait_implementation.rs

@@ -1,5 +1,4 @@
-use std::path::PathBuf;
-
+use frankenstein::input_file::InputFile;
 use frankenstein::methods::SendMessageParams;
 use frankenstein::response::ErrorResponse;
 use frankenstein::TelegramApi;
@@ -91,7 +90,7 @@ impl TelegramApi for MyApiClient {
         &self,
         _method: &str,
         _params: Params,
-        _files: Vec<(&str, PathBuf)>,
+        _files: Vec<(std::borrow::Cow<'static, str>, InputFile)>,
     ) -> Result<Output, Self::Error>
     where
         Params: serde::ser::Serialize + std::fmt::Debug,

examples/async_file_upload.rs

@@ -18,7 +18,7 @@ async fn main() {
         .chat_id(chat_id)
         .photo(file)
         .build();
-    match bot.send_photo(&params).await {
+    match bot.send_photo(params).await {
         Ok(response) => {
             println!("Photo was uploaded successfully");
             dbg!(response);

examples/file_upload.rs

@@ -0,0 +1,29 @@
+use frankenstein::client_ureq::Bot;
+use frankenstein::methods::SendPhotoParams;
+use frankenstein::TelegramApi;
+
+fn main() {
+    let token = std::env::var("BOT_TOKEN").expect("Should have BOT_TOKEN as environment variable");
+    let chat_id = std::env::var("TARGET_CHAT")
+        .expect("Should have TARGET_CHAT as environment variable")
+        .parse::<i64>()
+        .expect("TARGET_CHAT should be i64");
+
+    let bot = Bot::new(&token);
+
+    let file = std::path::PathBuf::from("./frankenstein_logo.png");
+
+    let params = SendPhotoParams::builder()
+        .chat_id(chat_id)
+        .photo(file)
+        .build();
+    match bot.send_photo(params) {
+        Ok(response) => {
+            println!("Photo was uploaded successfully");
+            dbg!(response);
+        }
+        Err(error) => {
+            eprintln!("Failed to upload photo: {error:?}");
+        }
+    }
+}

src/client_reqwest.rs

@@ -1,8 +1,8 @@
-use std::path::PathBuf;
-
 use async_trait::async_trait;
 use bon::Builder;
+use serde_json::Value;
 
+use crate::input_file::InputFile;
 use crate::trait_async::AsyncTelegramApi;
 use crate::Error;
 
@@ -93,51 +93,48 @@ impl AsyncTelegramApi for Bot {
         &self,
         method: &str,
         params: Params,
-        files: Vec<(&str, PathBuf)>,
+        files: Vec<(std::borrow::Cow<'static, str>, InputFile)>,
     ) -> Result<Output, Self::Error>
     where
         Params: serde::ser::Serialize + std::fmt::Debug + std::marker::Send,
         Output: serde::de::DeserializeOwned,
     {
-        #[cfg(not(target_arch = "wasm32"))]
-        {
-            use reqwest::multipart;
-            use serde_json::Value;
-
-            let json_string = crate::json::encode(&params)?;
-            let json_struct: Value = serde_json::from_str(&json_string).unwrap();
-
-            let file_keys: Vec<&str> = files.iter().map(|(key, _)| *key).collect();
-
-            let mut form = multipart::Form::new();
-            for (key, val) in json_struct.as_object().unwrap() {
-                if !file_keys.contains(&key.as_str()) {
-                    let val = match val {
-                        Value::String(val) => val.to_string(),
-                        other => other.to_string(),
-                    };
+        let json_string = crate::json::encode(&params)?;
+        let json_struct: serde_json::Map<String, Value> =
+            serde_json::from_str(&json_string).unwrap();
+        let file_keys: Vec<&str> = files.iter().map(|(key, _)| key.as_ref()).collect();
+
+        let mut form = reqwest::multipart::Form::new();
+        for (key, val) in json_struct {
+            if !file_keys.contains(&key.as_str()) {
+                let val = match val {
+                    Value::String(val) => val,
+                    other => other.to_string(),
+                };
+                form = form.text(key, val);
+            }
+        }
 
-                    form = form.text(key.clone(), val);
+        for (parameter_name, input_file) in files {
+            let part = match input_file {
+                InputFile::Bytes { bytes, file_name } => {
+                    // The reqwest::multipart stuff requires 'static which we can not grant here.
+                    // So we provide owned data by cloning it.
+                    reqwest::multipart::Part::bytes(bytes).file_name(file_name)
                 }
-            }
 
-            for (parameter_name, file_path) in files {
-                let file = tokio::fs::File::open(&file_path)
+                #[cfg(not(target_arch = "wasm32"))]
+                InputFile::Path(path) => reqwest::multipart::Part::file(path)
                     .await
-                    .map_err(Error::ReadFile)?;
-                let file_name = file_path.file_name().unwrap().to_string_lossy().to_string();
-                let part = multipart::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
+                    .map_err(crate::Error::ReadFile)?,
+            };
+            form = form.part(parameter_name, part);
         }
 
-        #[cfg(target_arch = "wasm32")]
-        Err(Error::WasmHasNoFileSupportYet)
+        let url = format!("{}/{method}", self.api_url);
+
+        let response = self.client.post(url).multipart(form).send().await?;
+        Self::decode_response(response).await
     }
 }