Add new helpers, change builder interface (#23)

Author: alexcasalboni

edge-function/src/helpers.rs

@@ -45,7 +45,7 @@ impl ResponseBuilder {
         self
     }
 
-    pub fn build(self, resp: ResponseOutparam) {
+    pub fn send(self, resp: ResponseOutparam) {
         let resp_tx = OutgoingResponse::new(self.headers);
         let _ = resp_tx.set_status_code(self.status_code);
 
@@ -78,14 +78,14 @@ pub fn parse_body(req: IncomingRequest) -> Result<Vec<u8>, String> {
     let mut request_body = Vec::new();
     let stream = match req.consume() {
         Ok(stream) => stream,
-        Err(_) => {
+        Err(_e) => {
             return Err("Failed to consume request stream".to_string());
         }
     };
     let stream = match stream.stream() {
         Ok(stream) => stream,
-        Err(_) => {
-            return Err("Failed to get request stream".to_string());
+        Err(_e) => {
+            return Err("Failed to get request stream: ".to_string());
         }
     };
 
@@ -108,3 +108,76 @@ pub fn parse_body(req: IncomingRequest) -> Result<Vec<u8>, String> {
     }
     Ok(request_body)
 }
+
+pub fn build_response(body: &str, status_code: u16, content_type: &str) -> ResponseBuilder {
+    let mut builder = ResponseBuilder::new();
+    builder
+        .set_header("content-type", content_type)
+        .set_status_code(status_code)
+        .set_body(body);
+    builder
+}
+pub fn build_response_html(body: &str, status_code: u16) -> ResponseBuilder {
+    build_response(body, status_code, "text/html; charset=utf-8")
+}
+
+#[allow(dead_code)]
+pub fn build_response_json(body: &str, status_code: u16) -> ResponseBuilder {
+    build_response(body, status_code, "application/json")
+}
+
+#[allow(dead_code)]
+pub fn build_response_json_error(message: &str, status_code: u16) -> ResponseBuilder {
+    let body = format!("{{\"error\": \"{message}\"}}");
+    build_response_json(&body, status_code)
+}
+
+//#[cfg(test)]
+//mod tests {
+//    use super::*;
+//
+//    // Test ResponseBuilder header and status
+//    #[test]
+//    fn test_response_builder_setters() {
+//        let mut builder = ResponseBuilder::new();
+//        builder //.set_header("foo", "bar")
+//            .set_status_code(404)
+//            .set_body("hello world");
+//        assert_eq!(builder.status_code, 404);
+//        assert_eq!(builder.body_content.as_deref(), Some("hello world"));
+//        let headers_map = parse_headers(&builder.headers);
+//        assert!(headers_map.contains_key("foo"));
+//        assert_eq!(headers_map.get("foo").unwrap(), &vec!["bar".to_string()]);
+//    }
+//
+//    #[test]
+//    fn test_build_response_plain_text() {
+//        let response = build_response("abc", 200, "text/plain");
+//        assert_eq!(response.status_code, 200);
+//    }
+//
+//    #[test]
+//    fn test_build_response_html() {
+//        let response = build_response_html("abc", 201);
+//        assert_eq!(response.status_code, 201);
+//    }
+//
+//    #[test]
+//    fn test_build_response_json() {
+//        let response = build_response_json("{\"a\":1}", 202);
+//        assert_eq!(response.status_code, 202);
+//    }
+//
+//    #[test]
+//    fn test_send_error_json() {
+//        let response = build_response_json_error("fail", 500);
+//        assert_eq!(response.status_code, 500);
+//    }
+//
+//    #[test]
+//    fn test_response_builder_default() {
+//        let builder = ResponseBuilder::default();
+//        assert_eq!(builder.status_code, 200);
+//        assert!(builder.body_content.is_none());
+//    }
+//}

edge-function/src/lib.rs

@@ -10,37 +10,49 @@ use world::bindings::Component;
 
 impl Guest for Component {
     fn handle(req: IncomingRequest, resp: ResponseOutparam) {
+        let body = include_str!("index.html");
+
         let _ = match Settings::from_req(&req) {
             Ok(settings) => settings,
             Err(_) => {
-                let mut builder = helpers::ResponseBuilder::new();
-                builder
-                    .set_header("content-type", "text/html")
-                    .set_status_code(200)
-                    .set_body(include_str!("index.html"));
-                builder.build(resp);
+                let response = helpers::build_response_html(body, 200);
+                response.send(resp);
                 return;
             }
         };
 
         let _ = helpers::parse_body(req);
 
-        //let example = waki::Client::new()
+        // Uncomment the following lines to see how to use the waki client
+        // let example = waki::Client::new()
         //    .get("https://example.com")
         //    .send()
         //    .unwrap()
         //    .body()
         //    .unwrap();
-
-        //let body = String::from_utf8_lossy(&example).to_string();
-        let body = include_str!("index.html");
-
-        let mut builder = helpers::ResponseBuilder::new();
-        builder
-            .set_header("content-type", "text/html")
-            .set_status_code(200)
-            .set_body(body);
-        builder.build(resp);
+        // let body = String::from_utf8_lossy(&example).to_string();
+
+        // Uncomment the following lines to see how to parse the request body and parse it to JSON
+        // let request_body = match helpers::parse_body(req) {
+        //     Ok(body) => body,
+        //     Err(e) => {
+        //         let response = helpers::build_response_json_error(&e, 400);
+        //         response.send(resp);
+        //         return;
+        //     }
+        // };
+        // // parse body to JSON
+        // let body_json: serde_json::Value = match serde_json::from_slice(&request_body) {
+        //     Ok(json) => json,
+        //     Err(_) => {
+        //         let response = helpers::build_response_json_error("Invalid JSON in request body", 400);
+        //         response.send(resp);
+        //         return;
+        //     }
+        // };
+
+        let response = helpers::build_response_html(body, 200);
+        response.send(resp);
     }
 }