From dd8fbeab4dcc33f7c253e0c31e4291251f5d450f Mon Sep 17 00:00:00 2001 From: Connor Hindley Date: Wed, 6 May 2026 23:17:08 -0500 Subject: [PATCH] wip: Support binary auto req/res. Currently broken without https://github.com/cloudflare/workerd/pull/6738 --- test/src/auto_response.rs | 37 ++++++++++++++++--- test/src/router.rs | 1 + test/tests/auto_response.spec.ts | 8 ++++ .../types/websocket_request_response_pair.rs | 13 +++++++ 4 files changed, 54 insertions(+), 5 deletions(-) diff --git a/test/src/auto_response.rs b/test/src/auto_response.rs index 38e1b429e..4ebaeaa48 100644 --- a/test/src/auto_response.rs +++ b/test/src/auto_response.rs @@ -1,5 +1,5 @@ use worker::{ - durable_object, DurableObject, Env, Request, Response, Result, State, + durable_object, js_sys::Uint8Array, DurableObject, Env, Request, Response, Result, State, WebSocketRequestResponsePair, }; @@ -16,11 +16,20 @@ impl DurableObject for AutoResponseObject { async fn fetch(&self, req: Request) -> Result { match req.path().as_str() { "/set" => { - // Configure ping -> pong auto-response for all websockets bound to this DO. let pair = WebSocketRequestResponsePair::new("ping", "pong")?; self.state.set_websocket_auto_response(&pair); Response::ok("ok") } + "/set-binary" => { + let request_data: &[u8] = &[0x01, 0x02, 0x03]; + let response_data: &[u8] = &[0x04, 0x05, 0x06]; + let pair = WebSocketRequestResponsePair::new_bytes( + &Uint8Array::from(request_data), + &Uint8Array::from(response_data), + )?; + self.state.set_websocket_auto_response(&pair); + Response::ok("ok") + } "/get" => { if let Some(pair) = self.state.get_websocket_auto_response() { let request_str = pair.request(); @@ -30,12 +39,20 @@ impl DurableObject for AutoResponseObject { Response::ok("none") } } + "/get-binary" => { + if let Some(pair) = self.state.get_websocket_auto_response() { + let req_bytes = pair.request_bytes().to_vec(); + let res_bytes = pair.response_bytes().to_vec(); + Response::ok(format!("{req_bytes:?}:{res_bytes:?}")) + } else { + Response::ok("none") + } + } _ => Response::error("Not Found", 404), } } } -// Route handler to exercise the Durable Object from tests. #[worker::send] pub async fn handle_auto_response( _req: Request, @@ -44,8 +61,18 @@ pub async fn handle_auto_response( ) -> Result { let namespace = env.durable_object("AUTO")?; let stub = namespace.id_from_name("singleton")?.get_stub()?; - // Ensure auto-response is configured stub.fetch_with_str("https://fake-host/set").await?; - // Retrieve and return it for assertion stub.fetch_with_str("https://fake-host/get").await } + +#[worker::send] +pub async fn handle_auto_response_binary( + _req: Request, + env: Env, + _data: crate::SomeSharedData, +) -> Result { + let namespace = env.durable_object("AUTO")?; + let stub = namespace.id_from_name("singleton-binary")?.get_stub()?; + stub.fetch_with_str("https://fake-host/set-binary").await?; + stub.fetch_with_str("https://fake-host/get-binary").await +} diff --git a/test/src/router.rs b/test/src/router.rs index b5a4b56b2..588829e25 100644 --- a/test/src/router.rs +++ b/test/src/router.rs @@ -219,6 +219,7 @@ macro_rules! add_routes ( add_route!($obj, get, "/socket/failed", socket::handle_socket_failed); add_route!($obj, get, "/socket/read", socket::handle_socket_read); add_route!($obj, get, "/durable/auto-response", auto_response::handle_auto_response); + add_route!($obj, get, "/durable/auto-response-binary", auto_response::handle_auto_response_binary); add_route!($obj, get, "/durable/hello", durable::handle_hello); add_route!($obj, get, "/durable/hello-unique", durable::handle_hello_unique); add_route!($obj, get, "/durable/storage", durable::handle_storage); diff --git a/test/tests/auto_response.spec.ts b/test/tests/auto_response.spec.ts index 5db04c800..98614c4f3 100644 --- a/test/tests/auto_response.spec.ts +++ b/test/tests/auto_response.spec.ts @@ -7,4 +7,12 @@ describe("durable object websocket auto-response", () => { const text = await resp.text(); expect(text).toBe("ping:pong"); }); + + test("set and get binary auto-response pair", async () => { + const resp = await mf.dispatchFetch( + `${mfUrl}durable/auto-response-binary` + ); + const text = await resp.text(); + expect(text).toBe("[1, 2, 3]:[4, 5, 6]"); + }); }); diff --git a/worker-sys/src/types/websocket_request_response_pair.rs b/worker-sys/src/types/websocket_request_response_pair.rs index 07bff4519..5f7590578 100644 --- a/worker-sys/src/types/websocket_request_response_pair.rs +++ b/worker-sys/src/types/websocket_request_response_pair.rs @@ -1,3 +1,4 @@ +use js_sys::Uint8Array; use wasm_bindgen::prelude::*; #[wasm_bindgen] @@ -9,9 +10,21 @@ extern "C" { #[wasm_bindgen(constructor, catch)] pub fn new(request: &str, response: &str) -> Result; + #[wasm_bindgen(constructor, catch, js_class = "WebSocketRequestResponsePair")] + pub fn new_bytes( + request: &Uint8Array, + response: &Uint8Array, + ) -> Result; + #[wasm_bindgen(method, getter)] pub fn request(this: &WebSocketRequestResponsePair) -> String; #[wasm_bindgen(method, getter)] pub fn response(this: &WebSocketRequestResponsePair) -> String; + + #[wasm_bindgen(method, getter, js_name = request)] + pub fn request_bytes(this: &WebSocketRequestResponsePair) -> Uint8Array; + + #[wasm_bindgen(method, getter, js_name = response)] + pub fn response_bytes(this: &WebSocketRequestResponsePair) -> Uint8Array; }