17 releases (10 stable)

1.0.9 Apr 29, 2023
1.0.4 Apr 27, 2023
0.1.6 Apr 24, 2023

#328 in Web programming

Download history 1/week @ 2023-11-10 18/week @ 2023-11-17 34/week @ 2023-11-24 53/week @ 2023-12-01 17/week @ 2023-12-15 34/week @ 2023-12-22 17/week @ 2023-12-29 17/week @ 2024-01-26 17/week @ 2024-02-02 19/week @ 2024-02-09 393/week @ 2024-02-16

446 downloads per month

MIT license

50KB
988 lines

myust: 📋=>🌐=>🦀

crates.io Documentation MIT

Introduction

myust is a rich and hybrid Rust wrapper for the mystb.in API that aims for user-flexibility.

myust supports hybrid clients:

⚠️ Synchronous clients are only available on the sync feature.

Authentication

You can authenticate with the API using the auth method with your mystb.in, example:

use myust::{Client, SyncClient};

let client = Client::new().auth("YOUR_MYSTBIN_TOKEN").await;
// or using synchronous client,
let client = SyncClient::new().auth("YOUR_MYSTBIN_TOKEN");

It will panic if the provided token is invalid.

Installation

Add myust = "1.0" to your Cargo.toml file.

[dependencies]
myust = "1.0"
tokio = "1.0"

If you want to use synchronous clients, add the sync feature.

[dependencies]
myust = { version = "1.0", features = ["sync"] }

Usage Examples

Asynchronously creating a paste with tomorrow expiration date, with error handling:

use myust::{Client, Expiry};

#[tokio::main]
async fn main() {
   let client = Client::new();
   let tomorrow = Expiry {
       days: 1,
       ..Default::default()
   }; // other fields default to 0
   let result = client
       .create_paste(|p| {
           p.filename("myust.txt")
               .content("Hello from myust!")
               .expires(tomorrow)
       })
       .await;
   match result {
       Ok(_) => {
           let paste = result.unwrap();
           println!("{paste:#?}");
           let url = format!("https://mystb.in/{}", paste.id);
           println!("Result: {}", url)
       }
       Err(_) => {
           println!("Error code: {}", result.unwrap_err().code)
       }
   }
}

Asynchronously deleting a paste (you must own the paste):

use myust::AuthClient;

#[tokio::main]
async fn main() {
    let client = AuthClient::new()
        .auth(std::env::var("MYSTBIN_TOKEN").unwrap())
        .await;
    let result = client.delete_paste("EquipmentMovingExpensive").await; // The paste ID to delete
    match result {
        Ok(_) => println!("Successfully deleted the paste."),
        Err(_) => {
            println!("Error code: {}", result.unwrap_err().code)
        }
    }
}

Synchronously creating a multifile paste with a password (you must have the sync feature enabled):

use myust::SyncClient;

fn main() {
    let client = SyncClient::new();
    let paste = client
        .create_multifile_paste(|p| {
            p.file(|f| {
                f.filename("myust1.txt")
                    .content("first file")
                    .password("myust")
            }); // set the password on the first file only, same for expiration date
            p.file(|f| f.filename("myust2.txt").content("second file"))
        })
        .unwrap();
    let url = format!("https://mystb.in/{}", paste.id);
    println!("Result: {}", url)
}

You can check for another example snippets in the test folder.

Help & Contributing

If you need any help regarding myust, feel free to open an issue about your problem, and feel free to make a pull request for code improvements, bugfixing, etc.

Dependencies

~6–20MB
~283K SLoC