feat(fetch): Add typed headers

Author: TatriX

examples/fetch/src/post.rs

@@ -24,9 +24,12 @@ pub fn update(msg: Msg, model: &mut Model, orders: &mut impl Orders<Msg>) {
         Msg::Submit => {
             orders.skip(); // No need to rerender
 
+            let token = "YWxhZGRpbjpvcGVuc2VzYW1l";
             // Created outside async block for lifetime reasons.
             let request = Request::new("/")
                 .method(Method::Post)
+                .header(header::custom("Accept-Language", "Rust"))
+                .header(header::custom("Authorization", format!("Basic {}", token)))
                 .json(&model.form)
                 .expect("Serialization failed");
 

src/browser/fetch.rs

@@ -36,11 +36,13 @@ use std::borrow::Cow;
 use wasm_bindgen_futures::JsFuture;
 use web_sys;
 
+pub mod header;
 mod method;
 mod request;
 mod response;
 mod status;
 
+pub use header::{Header, Headers};
 pub use method::*;
 pub use request::*;
 pub use response::*;
@@ -85,7 +87,7 @@ pub enum FetchError {
 /// `From` implementations for those types.
 pub enum Resource<'a> {
     String(Cow<'a, str>),
-    Request(Request),
+    Request(Request<'a>),
 }
 
 impl<'a> From<&'a str> for Resource<'a> {
@@ -106,8 +108,8 @@ impl From<Url> for Resource<'_> {
     }
 }
 
-impl From<Request> for Resource<'_> {
-    fn from(request: Request) -> Resource<'static> {
+impl<'a> From<Request<'a>> for Resource<'a> {
+    fn from(request: Request<'a>) -> Resource<'a> {
         Resource::Request(request)
     }
 }

src/browser/fetch/header.rs

@@ -0,0 +1,51 @@
+//! HTTP headers
+
+use std::borrow::Cow;
+
+/// Request headers.
+#[derive(Clone, Debug, Default)]
+pub struct Headers<'a>(Vec<Header<'a>>);
+
+impl<'a> Headers<'a> {
+    /// Sets a new value for an existing header or adds the header if
+    /// it does not already exist.
+    pub fn set(&mut self, header: Header<'a>) {
+        self.0.retain(|Header { name, .. }| &header.name != name);
+        self.0.push(header);
+    }
+}
+
+impl<'a> IntoIterator for Headers<'a> {
+    type Item = Header<'a>;
+    type IntoIter = std::vec::IntoIter<Self::Item>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.0.into_iter()
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct Header<'a> {
+    pub(crate) name: Cow<'a, str>,
+    pub(crate) value: Cow<'a, str>,
+}
+
+/// Create `Content-Type` header.
+pub fn content_type<'a>(value: impl Into<Cow<'a, str>>) -> Header<'a> {
+    custom("Content-Type", value.into())
+}
+
+/// Create `Authorization` header.
+pub fn authorization<'a>(value: impl Into<Cow<'a, str>>) -> Header<'a> {
+    custom("Authorization", value)
+}
+
+/// Create `Authorization: Bearer xxx` header.
+pub fn bearer<'a>(value: impl Into<Cow<'a, str>>) -> Header<'a> {
+    custom("Authorization", format!("Bearer {}", value.into()))
+}
+
+/// Create custom header.
+pub fn custom<'a>(name: impl Into<Cow<'a, str>>, value: impl Into<Cow<'a, str>>) -> Header<'a> {
+    Header { name: name.into(), value: value.into() }
+}

src/browser/fetch/request.rs

@@ -1,17 +1,17 @@
 //! The Request of the Fetch API.
 
-use super::{FetchError, Method, Result};
+use super::{header, FetchError, Header, Headers, Method, Result};
 use gloo_timers::callback::Timeout;
 use serde::Serialize;
-use std::{borrow::Cow, cell::RefCell, collections::HashMap, rc::Rc};
+use std::{borrow::Cow, cell::RefCell, rc::Rc};
 use wasm_bindgen::JsValue;
 
 /// Its methods configure the request, and handle the response. Many of them return the original
 /// struct, and are intended to be used chained together.
 #[derive(Debug, Clone, Default)]
-pub struct Request {
-    url: Cow<'static, str>,
-    headers: Headers,
+pub struct Request<'a> {
+    url: Cow<'a, str>,
+    headers: Headers<'a>,
     method: Method,
     body: Option<JsValue>,
     cache: Option<web_sys::RequestCache>,
@@ -25,14 +25,14 @@ pub struct Request {
     controller: RequestController,
 }
 
-impl Request {
+impl<'a> Request<'a> {
     /// Create new request based on the provided url.
     ///
     /// To get a [`Response`](./struct.Response.html) you need to pass
     /// `Request` to the [`fetch`](./fn.fetch.html) function.
     ///
     /// [MDN reference](https://developer.mozilla.org/en-US/docs/Web/API/Request)
-    pub fn new(url: impl Into<Cow<'static, str>>) -> Self {
+    pub fn new(url: impl Into<Cow<'a, str>>) -> Self {
         Self {
             url: url.into(),
             ..Self::default()
@@ -43,14 +43,14 @@ impl Request {
     #[allow(clippy::missing_const_for_fn)]
     /// Set headers for this request.
     /// It will replace any existing headers.
-    pub fn headers(mut self, headers: Headers) -> Self {
+    pub fn headers(mut self, headers: Headers<'a>) -> Self {
         self.headers = headers;
         self
     }
 
     /// Set specific header.
-    pub fn header(mut self, name: impl Into<String>, value: impl Into<String>) -> Self {
-        self.headers.insert(name.into(), value.into());
+    pub fn header(mut self, header: Header<'a>) -> Self {
+        self.headers.set(header);
         self
     }
 
@@ -85,10 +85,8 @@ impl Request {
     /// This method can fail if JSON serialization fail. It will then
     /// return `FetchError::SerdeError`.
     pub fn json<T: Serialize + ?Sized>(mut self, data: &T) -> Result<Self> {
-        self.headers.insert(
-            "Content-Type".to_owned(),
-            "application/json; charset=utf-8".to_owned(),
-        );
+        self.headers
+            .set(header::content_type("application/json; charset=utf-8"));
         let body = serde_json::to_string(data).map_err(FetchError::SerdeError)?;
         self.body = Some(body.into());
         Ok(self)
@@ -97,10 +95,8 @@ impl Request {
     /// Set request body to a provided string.
     /// It will also set `Content-Type` header to `text/plain; charset=utf-8`.
     pub fn text(mut self, text: impl AsRef<str>) -> Self {
-        self.headers.insert(
-            "Content-Type".to_owned(),
-            "text/plain; charset=utf-8".to_owned(),
-        );
+        self.headers
+            .set(header::content_type("text/plain; charset=utf-8"));
         self.body = Some(JsValue::from(text.as_ref()));
         self
     }
@@ -162,15 +158,15 @@ impl Request {
     }
 }
 
-impl From<Request> for web_sys::Request {
+impl From<Request<'_>> for web_sys::Request {
     fn from(request: Request) -> Self {
         let mut init = web_sys::RequestInit::new();
 
         // headers
         let headers = web_sys::Headers::new().expect("fetch: cannot create headers");
-        for (name, value) in &request.headers {
+        for header in request.headers {
             headers
-                .append(name.as_str(), value.as_str())
+                .append(&header.name, &header.value)
                 .expect("fetch: cannot create header")
         }
         init.headers(&headers);
@@ -242,10 +238,6 @@ impl From<Request> for web_sys::Request {
     }
 }
 
-// TODO cows?
-/// Request headers.
-pub type Headers = HashMap<String, String>;
-
 #[allow(clippy::module_name_repetitions)]
 #[derive(Debug, Clone)]
 /// It allows to abort request or disable request's timeout.

src/lib.rs

@@ -90,7 +90,7 @@ pub mod prelude {
         browser::dom::event_handler::{
             ev, input_ev, keyboard_ev, mouse_ev, pointer_ev, raw_ev, simple_ev,
         },
-        browser::fetch::{self, fetch, Method, Request, Response, Status},
+        browser::fetch::{self, fetch, header, Method, Request, Response, Status},
         browser::util::{
             request_animation_frame, ClosureNew, RequestAnimationFrameHandle,
             RequestAnimationFrameTime,