rikka 0.1.0

Async HTTP client for native & WASM.
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
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

use crate::error::Result;
use crate::response::Response;

/// HTTP request method.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
#[non_exhaustive]
pub enum Method {
    #[default]
    Get,
    Post,
    Put,
    Patch,
    Delete,
    Head,
    Options,
}

impl Method {
    #[must_use]
    pub fn as_str(self) -> &'static str {
        match self {
            Self::Get => "GET",
            Self::Post => "POST",
            Self::Put => "PUT",
            Self::Patch => "PATCH",
            Self::Delete => "DELETE",
            Self::Head => "HEAD",
            Self::Options => "OPTIONS",
        }
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum Redirect {
    /// Follow redirects automatically.
    #[default]
    Follow,
    /// Do not follow redirects; expose the 3xx response with its `Location`
    /// and `Set-Cookie` headers.
    ///
    /// On WASM this needs a runtime whose `fetch` returns the real 3xx in
    /// `manual` redirect mode (Node, Bun, Deno). Browsers return an opaque
    /// redirect instead: status 0 and no readable headers.
    Manual,
}

/// A request description, built with [`Request::builder`] then sent.
#[derive(Debug, Clone)]
pub struct Request {
    pub(crate) method: Method,
    pub(crate) url: String,
    pub(crate) headers: Vec<(String, String)>,
    pub(crate) cookies: Vec<(String, String)>,
    /// `application/x-www-form-urlencoded` body, if any.
    pub(crate) form: Option<Vec<(String, String)>>,
    pub(crate) redirect: Redirect,
}

impl Request {
    #[must_use]
    pub fn builder(url: impl Into<String>) -> RequestBuilder {
        RequestBuilder {
            inner: Request {
                method: Method::Get,
                url: url.into(),
                headers: Vec::new(),
                cookies: Vec::new(),
                form: None,
                redirect: Redirect::Follow,
            },
        }
    }

    /// The `Cookie` header line for the requested cookies, if any.
    pub(crate) fn cookie_header(&self) -> Option<String> {
        if self.cookies.is_empty() {
            return None;
        }

        Some(
            self.cookies
                .iter()
                .map(|(k, v)| format!("{k}={v}"))
                .collect::<Vec<_>>()
                .join("; "),
        )
    }

    /// Whether the caller already set a `Content-Type` header.
    #[cfg(target_arch = "wasm32")]
    pub(crate) fn has_content_type(&self) -> bool {
        self.headers
            .iter()
            .any(|(key, _)| key.eq_ignore_ascii_case("content-type"))
    }
}

pub struct RequestBuilder {
    inner: Request,
}

impl RequestBuilder {
    #[must_use]
    pub fn method(mut self, method: Method) -> Self {
        self.inner.method = method;
        self
    }

    #[must_use]
    pub fn post(self) -> Self {
        self.method(Method::Post)
    }

    #[must_use]
    pub fn header(mut self, key: impl Into<String>, value: impl Into<String>) -> Self {
        self.inner.headers.push((key.into(), value.into()));
        self
    }

    #[must_use]
    pub fn cookie(mut self, key: impl Into<String>, value: impl Into<String>) -> Self {
        self.inner.cookies.push((key.into(), value.into()));
        self
    }

    /// Set an `application/x-www-form-urlencoded` body.
    #[must_use]
    pub fn form(mut self, body: Vec<(String, String)>) -> Self {
        self.inner.form = Some(body);
        self
    }

    #[must_use]
    pub fn redirect(mut self, redirect: Redirect) -> Self {
        self.inner.redirect = redirect;
        self
    }

    #[must_use]
    pub fn build(self) -> Request {
        self.inner
    }

    pub async fn send(self) -> Result<Response> {
        crate::send(self.build()).await
    }
}