Refine builder pattern

worker-sandbox/src/cache.rs

@@ -2,7 +2,7 @@ use super::SomeSharedData;
 use futures_util::stream::StreamExt;
 use rand::Rng;
 use std::time::Duration;
-use worker::{console_log, Cache, Date, Delay, Env, Request, Response, Result};
+use worker::{console_log, Cache, Date, Delay, Env, Request, Response, ResponseBuilder, Result};
 
 fn key(req: &Request) -> Result<Option<String>> {
     let uri = req.url()?;
@@ -24,12 +24,11 @@ pub async fn handle_cache_example(
         Ok(resp)
     } else {
         console_log!("Cache MISS!");
-        let mut resp =
-            Response::from_json(&serde_json::json!({ "timestamp": Date::now().as_millis() }))?;
-
         // Cache API respects Cache-Control headers. Setting s-max-age to 10
         // will limit the response to be in cache for 10 seconds max
-        resp.headers_mut().set("cache-control", "s-maxage=10")?;
+        let mut resp = ResponseBuilder::new()
+            .with_header("cache-control", "s-maxage=10")?
+            .from_json(&serde_json::json!({ "timestamp": Date::now().as_millis() }))?;
         cache.put(key, resp.cloned()?).await?;
         Ok(resp)
     }
@@ -60,13 +59,11 @@ pub async fn handle_cache_api_put(
 ) -> Result<Response> {
     if let Some(key) = key(&req)? {
         let cache = Cache::default();
-
-        let mut resp =
-            Response::from_json(&serde_json::json!({ "timestamp": Date::now().as_millis() }))?;
-
         // Cache API respects Cache-Control headers. Setting s-max-age to 10
         // will limit the response to be in cache for 10 seconds max
-        resp.headers_mut().set("cache-control", "s-maxage=10")?;
+        let mut resp = ResponseBuilder::new()
+            .with_header("cache-control", "s-maxage=10")?
+            .from_json(&serde_json::json!({ "timestamp": Date::now().as_millis() }))?;
         cache.put(format!("https://{key}"), resp.cloned()?).await?;
         return Ok(resp);
     }
@@ -111,12 +108,12 @@ pub async fn handle_cache_stream(
                 Result::Ok(text.as_bytes().to_vec())
             });
 
-        let mut resp = Response::from_stream(stream)?;
-        console_log!("resp = {:?}", resp);
         // Cache API respects Cache-Control headers. Setting s-max-age to 10
         // will limit the response to be in cache for 10 seconds max
-        resp.headers_mut().set("cache-control", "s-maxage=10")?;
-
+        let mut resp = ResponseBuilder::new()
+            .with_header("cache-control", "s-maxage=10")?
+            .from_stream(stream)?;
+        console_log!("resp = {:?}", resp);
         cache.put(key, resp.cloned()?).await?;
         Ok(resp)
     }

worker-sandbox/src/counter.rs

@@ -34,10 +34,10 @@ impl DurableObject for Counter {
                 .serialize_attachment("hello")
                 .expect("failed to serialize attachment");
 
-            return Ok(Response::empty()
-                .unwrap()
+            return Ok(ResponseBuilder::new()
                 .with_status(101)
-                .with_websocket(Some(pair.client)));
+                .with_websocket(pair.client)
+                .empty());
         }
 
         self.count += 10;

worker-sandbox/src/request.rs

@@ -5,7 +5,7 @@ use futures_util::StreamExt;
 use futures_util::TryStreamExt;
 use std::time::Duration;
 use worker::Env;
-use worker::{console_log, Date, Delay, Request, Response, ResponseBody, Result};
+use worker::{console_log, Date, Delay, Request, Response, ResponseBody, ResponseBuilder, Result};
 pub fn handle_a_request(req: Request, _env: Env, _data: SomeSharedData) -> Result<Response> {
     Response::ok(format!(
         "req at: {}, located at: {:?}, within: {}",
@@ -60,7 +60,9 @@ pub async fn handle_headers(req: Request, _env: Env, _data: SomeSharedData) -> R
     let mut headers: http::HeaderMap = req.headers().into();
     headers.append("Hello", "World!".parse().unwrap());
 
-    Response::ok("returned your headers to you.").map(|res| res.with_headers(headers.into()))
+    ResponseBuilder::new()
+        .with_headers(headers.into())
+        .ok("returned your headers to you.")
 }
 
 #[worker::send]
@@ -133,9 +135,9 @@ pub async fn handle_status(req: Request, _env: Env, _data: SomeSharedData) -> Re
     let code = segments.nth(1);
     if let Some(code) = code {
         return match code.parse::<u16>() {
-            Ok(status) => {
-                Response::ok("You set the status code!").map(|resp| resp.with_status(status))
-            }
+            Ok(status) => ResponseBuilder::new()
+                .with_status(status)
+                .ok("You set the status code!"),
             Err(_e) => Response::error("Failed to parse your status code.", 400),
         };
     }

worker-sandbox/src/router.rs

@@ -6,7 +6,7 @@ use crate::{
 use std::convert::TryInto;
 use std::sync::atomic::Ordering;
 
-use worker::{console_log, Env, Fetch, Headers, Request, Response, Result};
+use worker::{console_log, Env, Fetch, Request, Response, ResponseBuilder, Result};
 
 #[cfg(not(feature = "http"))]
 use worker::{RouteContext, Router};
@@ -348,19 +348,15 @@ pub fn make_router<'a>(data: SomeSharedData) -> Router<'a, SomeSharedData> {
 }
 
 fn respond(req: Request, _env: Env, _data: SomeSharedData) -> Result<Response> {
-    Response::ok(format!("Ok: {}", String::from(req.method()))).map(|resp| {
-        let mut headers = Headers::new();
-        headers.set("x-testing", "123").unwrap();
-        resp.with_headers(headers)
-    })
+    ResponseBuilder::new()
+        .with_header("x-testing", "123")?
+        .ok(format!("Ok: {}", String::from(req.method())))
 }
 
 async fn respond_async(req: Request, _env: Env, _data: SomeSharedData) -> Result<Response> {
-    Response::ok(format!("Ok (async): {}", String::from(req.method()))).map(|resp| {
-        let mut headers = Headers::new();
-        headers.set("x-testing", "123").unwrap();
-        resp.with_headers(headers)
-    })
+    ResponseBuilder::new()
+        .with_header("x-testing", "123")?
+        .ok(format!("Ok (async): {}", String::from(req.method())))
 }
 
 #[worker::send]
@@ -382,10 +378,12 @@ async fn catchall(req: Request, _env: Env, _data: SomeSharedData) -> Result<Resp
     let path = uri.path();
     console_log!("[or_else_any_method_async] caught: {}", path);
 
-    Fetch::Url("https://github.com/404".parse().unwrap())
+    let (builder, body) = Fetch::Url("https://github.com/404".parse().unwrap())
         .send()
-        .await
-        .map(|resp| resp.with_status(404))
+        .await?
+        .into_parts();
+
+    Ok(builder.with_status(404).body(body))
 }
 
 async fn handle_options_catchall(

worker/src/lib.rs

@@ -184,7 +184,7 @@ pub use crate::queue::*;
 pub use crate::r2::*;
 pub use crate::request::{FromRequest, Request};
 pub use crate::request_init::*;
-pub use crate::response::{IntoResponse, Response, ResponseBody};
+pub use crate::response::{IntoResponse, Response, ResponseBody, ResponseBuilder};
 pub use crate::router::{RouteContext, RouteParams, Router};
 pub use crate::schedule::*;
 pub use crate::socket::*;