lyceris 1.1.3

An open source Minecraft launcher library.
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

use reqwest::{Client, IntoUrl, Response};
use serde::{de::DeserializeOwned, Serialize};
use std::collections::HashMap;

/// A struct to hold optional fetch request parameters.
#[derive(Default)]
pub struct FetchOptions<B: Serialize> {
    pub method: reqwest::Method,
    pub headers: HashMap<String, String>,
    pub query_params: HashMap<String, String>,
    pub body: Option<B>,
}

pub async fn fetch<T: DeserializeOwned>(
    url: impl IntoUrl,
    client: Option<&Client>,
) -> crate::Result<T> {
    // Call the fetch function with default options
    let default_client = Client::default();
    fetch_with_options::<T, ()>(url, None, client.unwrap_or(&default_client)).await
}

/// Performs a customizable fetch request.
///
/// This function allows you to send HTTP requests with various options, including
/// the HTTP method, headers, query parameters, and body. If no options are provided,
/// it defaults to a GET request that returns JSON.
///
/// # Parameters
///
/// - `url`: A string slice representing the URL to send the request to.
/// - `options`: An optional `FetchOptions` struct that contains parameters for the request.
///   If not provided, the function defaults to a GET request with no additional parameters.
///
/// # Type Parameters
///
/// - `T`: The type to which the response will be deserialized. This type must implement
///   the `DeserializeOwned` trait from the `serde` crate.
/// - `B`: The type of the body to be sent with the request. This type must implement
///   the `Serialize` trait from the `serde` crate.
///
/// # Returns
///
/// Returns a `Result<T, Error>`, where `T` is the type to which the response will be deserialized.
/// On success, it returns `Ok(T)`, where `T` is the deserialized response. On failure,
/// it returns an `Err(Error)` containing the error information.
///
/// # Errors
///
/// The function can fail in several ways, including but not limited to:
/// - Network errors when sending the request.
/// - Non-success HTTP status codes (e.g., 404 Not Found).
/// - Errors during the deserialization of the response body.
pub async fn fetch_with_options<T: DeserializeOwned, B: Serialize + Default>(
    url: impl IntoUrl,
    options: Option<FetchOptions<B>>,
    client: &Client,
) -> crate::Result<T> {
    let options = options.unwrap_or_default(); // Use default options if none provided

    let mut request_builder = client.request(options.method.clone(), url);

    // Add headers if provided
    for (key, value) in options.headers {
        request_builder = request_builder.header(key, value);
    }

    // Add query parameters if provided
    for (key, value) in options.query_params {
        request_builder = request_builder.query(&[(key, value)]);
    }

    // Add body if provided
    if let Some(b) = options.body {
        request_builder = request_builder.json(&b);
    }

    // Send the request and await the response
    let response: Response = request_builder.send().await?;

    // Deserialize the response body
    Ok(response.json::<T>().await?)
}