feat, examples: Request::controller; server_integration - new Fetch API; IntoNodes for Options

Author: MartinKavik

CHANGELOG.md

@@ -37,7 +37,9 @@
 - [BREAKING] `Node::add_listener` renamed to `add_event_handler`.
 - Rewritten `README.md`.
 - Added new Fetch API module. See [`seed::browser::fetch`](https://docs.rs/seed/0.7.0/seed/browser/fetch/index.html) (#353)
-- [deprecated] - `seed::browser::service::fetch` module is deprecated in favor of `seed::browser::fetch`
+- [deprecated] - `seed::browser::service::fetch` module is deprecated in favor of `seed::browser::fetch`.
+- Added example `fetch`.
+- Implemented `IntoNodes` for `Option<Node<Msg>>` and `Option<Vec<Node<Msg>>>`.
 
 ## v0.6.0
 - Implemented `UpdateEl` for `Filter` and `FilterMap`.

examples/fetch/src/simple.rs

@@ -43,10 +43,9 @@ pub fn update(msg: Msg, model: &mut Model, orders: &mut impl Orders<Msg>) {
 pub fn view(model: &Model) -> Node<Msg> {
     div![
         button![ev(Ev::Click, |_| Msg::Fetch), "Fetch user"],
-        if let Some(user) = &model.user {
-            div![format!("User: {}", user.name)]
-        } else {
-            empty![]
-        }
+        model
+            .user
+            .as_ref()
+            .map(|user| div![format!("User: {}", user.name)])
     ]
 }

examples/server_integration/client/src/example_a.rs

@@ -1,4 +1,3 @@
-use seed::browser::service::fetch;
 use seed::{self, prelude::*, *};
 use std::borrow::Cow;
 
@@ -30,7 +29,7 @@ pub struct Model {
 pub enum Msg {
     NewMessageChanged(String),
     SendRequest,
-    Fetched(fetch::ResponseDataResult<shared::SendMessageResponseBody>),
+    Fetched(fetch::Result<shared::SendMessageResponseBody>),
 }
 
 pub fn update(msg: Msg, model: &mut Model, orders: &mut impl Orders<Msg>) {
@@ -39,28 +38,29 @@ pub fn update(msg: Msg, model: &mut Model, orders: &mut impl Orders<Msg>) {
             model.new_message = message;
         }
         Msg::SendRequest => {
-            orders
-                .skip()
-                .perform_cmd(send_request(model.new_message.clone()));
+            orders.skip().perform_cmd({
+                let message = model.new_message.clone();
+                async { Msg::Fetched(send_message(message).await) }
+            });
         }
 
         Msg::Fetched(Ok(response_data)) => {
             model.response_data = Some(response_data);
         }
 
-        Msg::Fetched(Err(fail_reason)) => {
-            log!("Example_A error:", fail_reason);
+        Msg::Fetched(Err(fetch_error)) => {
+            log!("Example_A error:", fetch_error);
             orders.skip();
         }
     }
 }
 
-async fn send_request(new_message: String) -> Msg {
-    fetch::Request::new(get_request_url())
-        .method(fetch::Method::Post)
-        .send_json(&shared::SendMessageRequestBody { text: new_message })
-        .fetch_json_data(Msg::Fetched)
-        .await
+async fn send_message(new_message: String) -> fetch::Result<shared::SendMessageResponseBody> {
+    let request = Request::new(get_request_url())
+        .method(Method::Post)
+        .json(&shared::SendMessageRequestBody { text: new_message })?;
+
+    fetch(request).await?.check_status()?.json().await
 }
 
 // ------ ------

examples/server_integration/client/src/example_b.rs

@@ -1,12 +1,11 @@
-use seed::browser::service::fetch;
 use seed::{prelude::*, *};
 use serde::Deserialize;
 use std::borrow::Cow;
 
 pub const TITLE: &str = "Example B";
 pub const DESCRIPTION: &str =
     "Click button 'Try to Fetch JSON' to send request to non-existent endpoint.
-    Server will return 404 with empty body and Serde then fail to decode body into predefined JSON.";
+    Server will return status 404 with empty body. `Response::check_status` then return error.";
 
 fn get_request_url() -> impl Into<Cow<'static, str>> {
     "/api/non-existent-endpoint"
@@ -18,10 +17,10 @@ fn get_request_url() -> impl Into<Cow<'static, str>> {
 
 #[derive(Default)]
 pub struct Model {
-    pub response_with_data_result: Option<fetch::ResponseWithDataResult<ExpectedResponseData>>,
+    pub fetch_result: Option<fetch::Result<ExpectedResponseData>>,
 }
 
-#[derive(Debug, Deserialize, Clone)]
+#[derive(Debug, Deserialize)]
 pub struct ExpectedResponseData {
     something: String,
 }
@@ -32,47 +31,36 @@ pub struct ExpectedResponseData {
 
 pub enum Msg {
     SendRequest,
-    Fetched(fetch::FetchResult<ExpectedResponseData>),
+    Fetched(fetch::Result<ExpectedResponseData>),
 }
 
 pub fn update(msg: Msg, model: &mut Model, orders: &mut impl Orders<Msg>) {
     match msg {
         Msg::SendRequest => {
-            orders.skip().perform_cmd(send_request());
+            orders.skip().perform_cmd(async {
+                Msg::Fetched(
+                    async { fetch(get_request_url()).await?.check_status()?.json().await }.await,
+                )
+            });
         }
 
-        Msg::Fetched(Ok(response_with_data_result)) => {
-            model.response_with_data_result = Some(response_with_data_result);
-        }
-
-        Msg::Fetched(Err(request_error)) => {
-            log!("Example_B error:", request_error);
-            orders.skip();
+        Msg::Fetched(fetch_result) => {
+            model.fetch_result = Some(fetch_result);
         }
     }
 }
 
-async fn send_request() -> Msg {
-    fetch::Request::new(get_request_url())
-        .fetch_json(|fetch_object| Msg::Fetched(fetch_object.result))
-        .await
-}
-
 // ------ ------
 //     View
 // ------ ------
 
 pub fn view(model: &Model, intro: impl FnOnce(&str, &str) -> Vec<Node<Msg>>) -> Vec<Node<Msg>> {
     nodes![
         intro(TITLE, DESCRIPTION),
-        match &model.response_with_data_result {
-            None => empty![],
-            Some(fetch::ResponseWithDataResult { status, data, .. }) => div![
-                div![format!("Status code: {}", status.code)],
-                div![format!(r#"Status text: "{}""#, status.text)],
-                div![format!(r#"Data: "{:#?}""#, data)]
-            ],
-        },
+        model
+            .fetch_result
+            .as_ref()
+            .map(|result| div![format!("{:#?}", result)]),
         button![ev(Ev::Click, |_| Msg::SendRequest), "Try to Fetch JSON"],
     ]
 }

examples/server_integration/client/src/example_c.rs

@@ -1,4 +1,4 @@
-use seed::browser::service::fetch;
+// use seed::browser::service::fetch;
 use seed::{prelude::*, *};
 use std::borrow::Cow;
 
@@ -18,7 +18,7 @@ fn get_request_url() -> impl Into<Cow<'static, str>> {
 
 #[derive(Default)]
 pub struct Model {
-    pub response_data_result: Option<fetch::ResponseDataResult<String>>,
+    pub fetch_result: Option<fetch::Result<String>>,
     pub request_controller: Option<fetch::RequestController>,
     pub status: Status,
 }
@@ -42,31 +42,31 @@ impl Default for Status {
 pub enum Msg {
     SendRequest,
     AbortRequest,
-    Fetched(fetch::ResponseDataResult<String>),
+    Fetched(fetch::Result<String>),
 }
 
 pub fn update(msg: Msg, model: &mut Model, orders: &mut impl Orders<Msg>) {
     match msg {
         Msg::SendRequest => {
+            let (request, controller) = Request::new(get_request_url()).controller();
             model.status = Status::WaitingForResponse;
-            model.response_data_result = None;
-            let request = fetch::Request::new(get_request_url())
-                .controller(|controller| model.request_controller = Some(controller));
-            orders.perform_cmd(request.fetch_string_data(Msg::Fetched));
+            model.fetch_result = None;
+            model.request_controller = Some(controller);
+            orders.perform_cmd(async {
+                Msg::Fetched(async { fetch(request).await?.text().await }.await)
+            });
         }
 
         Msg::AbortRequest => {
-            model
-                .request_controller
-                .take()
-                .expect("AbortRequest: request_controller hasn't been set!")
-                .abort();
+            if let Some(controller) = &model.request_controller {
+                controller.abort();
+            }
             model.status = Status::RequestAborted;
         }
 
-        Msg::Fetched(response_data_result) => {
+        Msg::Fetched(fetch_result) => {
             model.status = Status::ReadyToSendRequest;
-            model.response_data_result = Some(response_data_result);
+            model.fetch_result = Some(fetch_result);
         }
     }
 }
@@ -79,16 +79,22 @@ pub fn view(model: &Model, intro: impl FnOnce(&str, &str) -> Vec<Node<Msg>>) ->
     nodes![
         intro(TITLE, DESCRIPTION),
         match model.status {
-            Status::ReadyToSendRequest => vec![
-                view_response_data_result(&model.response_data_result),
+            Status::ReadyToSendRequest => nodes![
+                model
+                    .fetch_result
+                    .as_ref()
+                    .map(|result| div![format!("{:#?}", result)]),
                 button![ev(Ev::Click, |_| Msg::SendRequest), "Send request"],
             ],
-            Status::WaitingForResponse => vec![
+            Status::WaitingForResponse => nodes![
                 div!["Waiting for response..."],
                 button![ev(Ev::Click, |_| Msg::AbortRequest), "Abort request"],
             ],
-            Status::RequestAborted => vec![
-                view_response_data_result(&model.response_data_result),
+            Status::RequestAborted => nodes![
+                model
+                    .fetch_result
+                    .as_ref()
+                    .map(|result| div![format!("{:#?}", result)]),
                 button![
                     attrs! {At::Disabled => false.as_at_value()},
                     "Request aborted"
@@ -97,28 +103,3 @@ pub fn view(model: &Model, intro: impl FnOnce(&str, &str) -> Vec<Node<Msg>>) ->
         }
     ]
 }
-
-fn view_response_data_result(
-    response_data_result: &Option<fetch::ResponseDataResult<String>>,
-) -> Node<Msg> {
-    match &response_data_result {
-        None => empty![],
-        Some(Ok(response_data)) => div![format!(r#"Response String body: "{}""#, response_data)],
-        Some(Err(fail_reason)) => view_fail_reason(fail_reason),
-    }
-}
-
-fn view_fail_reason(fail_reason: &fetch::FailReason<String>) -> Node<Msg> {
-    if let fetch::FailReason::RequestError(fetch::RequestError::DomException(dom_exception), _) =
-        fail_reason
-    {
-        if dom_exception.name() == "AbortError" {
-            return div![
-                div![format!(r#"Error name: "{}""#, dom_exception.name())],
-                div![format!(r#"Error message: "{}""#, dom_exception.message())]
-            ];
-        }
-    }
-    log!("Example_C error:", fail_reason);
-    empty![]
-}

examples/server_integration/client/src/example_d.rs

@@ -1,4 +1,3 @@
-use seed::browser::service::fetch;
 use seed::{prelude::*, *};
 use std::borrow::Cow;
 
@@ -20,7 +19,7 @@ fn get_request_url() -> impl Into<Cow<'static, str>> {
 
 #[derive(Default)]
 pub struct Model {
-    pub response_result: Option<fetch::ResponseResult<()>>,
+    pub fetch_result: Option<fetch::Result<String>>,
     pub request_controller: Option<fetch::RequestController>,
     pub status: Status,
 }
@@ -48,34 +47,35 @@ impl Default for Status {
 pub enum Msg {
     SendRequest,
     DisableTimeout,
-    Fetched(fetch::FetchObject<()>),
+    Fetched(fetch::Result<String>),
 }
 
 pub fn update(msg: Msg, model: &mut Model, orders: &mut impl Orders<Msg>) {
     match msg {
         Msg::SendRequest => {
+            let (request, controller) = Request::new(get_request_url())
+                .timeout(TIMEOUT)
+                .controller();
+
             model.status = Status::WaitingForResponse(TimeoutStatus::Enabled);
-            model.response_result = None;
+            model.fetch_result = None;
+            model.request_controller = Some(controller);
 
-            let request = fetch::Request::new(get_request_url())
-                .controller(|controller| model.request_controller = Some(controller))
-                .timeout(TIMEOUT);
-            orders.perform_cmd(request.fetch(Msg::Fetched));
+            orders.perform_cmd(async {
+                Msg::Fetched(async { fetch(request).await?.text().await }.await)
+            });
         }
 
         Msg::DisableTimeout => {
-            model
-                .request_controller
-                .take()
-                .ok_or("Msg:DisableTimeout: request controller cannot be None")
-                .and_then(|controller| controller.disable_timeout())
-                .unwrap_or_else(|err| log!(err));
+            if let Some(controller) = &model.request_controller {
+                controller.disable_timeout().expect("disable timeout");
+            }
             model.status = Status::WaitingForResponse(TimeoutStatus::Disabled)
         }
 
-        Msg::Fetched(fetch_object) => {
+        Msg::Fetched(fetch_result) => {
             model.status = Status::ReadyToSendRequest;
-            model.response_result = Some(fetch_object.response());
+            model.fetch_result = Some(fetch_result);
         }
     }
 }
@@ -87,36 +87,16 @@ pub fn update(msg: Msg, model: &mut Model, orders: &mut impl Orders<Msg>) {
 pub fn view(model: &Model, intro: impl FnOnce(&str, &str) -> Vec<Node<Msg>>) -> Vec<Node<Msg>> {
     nodes![
         intro(TITLE, DESCRIPTION),
-        match &model.response_result {
-            None => vec![
-                if let Status::WaitingForResponse(_) = model.status {
-                    div!["Waiting for response..."]
-                } else {
-                    empty![]
-                },
-                view_button(&model.status),
-            ],
-            Some(Ok(response)) => vec![
-                div![format!("Server returned {}.", response.status.text)],
-                view_button(&model.status),
-            ],
-            Some(Err(fail_reason)) => view_fail_reason(fail_reason, &model.status),
-        }
+        match &model.fetch_result {
+            None =>
+                IF!(matches!(model.status, Status::WaitingForResponse(_)) => div!["Waiting for response..."]),
+            Some(Ok(result)) => Some(div![format!("Server returned: {:#?}", result)]),
+            Some(Err(fetch_error)) => Some(div![format!("{:#?}", fetch_error)]),
+        },
+        view_button(&model.status),
     ]
 }
 
-fn view_fail_reason(fail_reason: &fetch::FailReason<()>, status: &Status) -> Vec<Node<Msg>> {
-    if let fetch::FailReason::RequestError(fetch::RequestError::DomException(dom_exception), _) =
-        fail_reason
-    {
-        if dom_exception.name() == "AbortError" {
-            return vec![div!["Request aborted."], view_button(status)];
-        }
-    }
-    log!("Example_D error:", fail_reason);
-    vec![]
-}
-
 pub fn view_button(status: &Status) -> Node<Msg> {
     match status {
         Status::WaitingForResponse(TimeoutStatus::Enabled) => {