refactor(op_crates/websocket): use Serialize for return values (#10220)

2 files changed, 95 insertions, 99 deletions

diff --git a/op_crates/websocket/01_websocket.js b/op_crates/websocket/01_websocket.js
index 17ba601a2..a37cd01cc 100644
--- a/op_crates/websocket/01_websocket.js
+++ b/op_crates/websocket/01_websocket.js
@@ -312,74 +312,55 @@
           this.#rid,
         );
 
-        switch (message.kind) {
-          case "string": {
-            const event = new MessageEvent("message", {
-              data: message.data,
-              origin: this.#url,
-            });
-            event.target = this;
-            this.dispatchEvent(event);
-
-            break;
-          }
-
-          case "binary": {
-            let data;
-
-            if (this.binaryType === "blob") {
-              data = new Blob([new Uint8Array(message.data)]);
-            } else {
-              data = new Uint8Array(message.data).buffer;
-            }
-
-            const event = new MessageEvent("message", {
-              data,
-              origin: this.#url,
-            });
-            event.target = this;
-            this.dispatchEvent(event);
-
-            break;
-          }
-
-          case "ping":
-            core.opAsync("op_ws_send", {
-              rid: this.#rid,
-              kind: "pong",
-            });
-
-            break;
-
-          case "close": {
-            this.#readyState = CLOSED;
-
-            const event = new CloseEvent("close", {
-              wasClean: true,
-              code: message.data.code,
-              reason: message.data.reason,
-            });
-            event.target = this;
-            this.dispatchEvent(event);
-            tryClose(this.#rid);
+        if ("string" in message) {
+          const event = new MessageEvent("message", {
+            data: message.string,
+            origin: this.#url,
+          });
+          event.target = this;
+          this.dispatchEvent(event);
+        } else if ("binary" in message) {
+          let data;
 
-            break;
+          if (this.binaryType === "blob") {
+            data = new Blob([new Uint8Array(message.binary)]);
+          } else {
+            data = new Uint8Array(message.binary).buffer;
           }
 
-          case "error": {
-            this.#readyState = CLOSED;
+          const event = new MessageEvent("message", {
+            data,
+            origin: this.#url,
+          });
+          event.target = this;
+          this.dispatchEvent(event);
+        } else if ("ping" in message) {
+          core.opAsync("op_ws_send", {
+            rid: this.#rid,
+            kind: "pong",
+          });
+        } else if ("close" in message) {
+          this.#readyState = CLOSED;
 
-            const errorEv = new ErrorEvent("error");
-            errorEv.target = this;
-            this.dispatchEvent(errorEv);
+          const event = new CloseEvent("close", {
+            wasClean: true,
+            code: message.close.code,
+            reason: message.close.reason,
+          });
+          event.target = this;
+          this.dispatchEvent(event);
+          tryClose(this.#rid);
+        } else if ("error" in message) {
+          this.#readyState = CLOSED;
 
-            const closeEv = new CloseEvent("close");
-            closeEv.target = this;
-            this.dispatchEvent(closeEv);
-            tryClose(this.#rid);
+          const errorEv = new ErrorEvent("error");
+          errorEv.target = this;
+          this.dispatchEvent(errorEv);
 
-            break;
-          }
+          const closeEv = new CloseEvent("close");
+          closeEv.target = this;
+          this.dispatchEvent(closeEv);
+          tryClose(this.#rid);
         }
       }
     }
diff --git a/op_crates/websocket/lib.rs b/op_crates/websocket/lib.rs
index 930424aab..c7567c197 100644
--- a/op_crates/websocket/lib.rs
+++ b/op_crates/websocket/lib.rs
@@ -8,8 +8,6 @@ use deno_core::futures::stream::SplitSink;
 use deno_core::futures::stream::SplitStream;
 use deno_core::futures::SinkExt;
 use deno_core::futures::StreamExt;
-use deno_core::serde_json::json;
-use deno_core::serde_json::Value;
 use deno_core::url;
 use deno_core::AsyncRefCell;
 use deno_core::CancelFuture;
@@ -23,6 +21,7 @@ use deno_core::ZeroCopyBuf;
 
 use http::{Method, Request, Uri};
 use serde::Deserialize;
+use serde::Serialize;
 use std::borrow::Cow;
 use std::cell::RefCell;
 use std::io::BufReader;
@@ -104,11 +103,20 @@ pub struct CreateArgs {
   protocols: String,
 }
 
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CreateResponse {
+  success: bool,
+  rid: Option<ResourceId>,
+  protocol: Option<String>,
+  extensions: Option<String>,
+}
+
 pub async fn op_ws_create<WP>(
   state: Rc<RefCell<OpState>>,
   args: CreateArgs,
   _bufs: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError>
+) -> Result<CreateResponse, AnyError>
 where
   WP: WebSocketPermissions + 'static,
 {
@@ -143,7 +151,14 @@ where
   let try_socket = TcpStream::connect(addr).await;
   let tcp_socket = match try_socket.map_err(TungsteniteError::Io) {
     Ok(socket) => socket,
-    Err(_) => return Ok(json!({ "success": false })),
+    Err(_) => {
+      return Ok(CreateResponse {
+        success: false,
+        rid: None,
+        protocol: None,
+        extensions: None,
+      })
+    }
   };
 
   let socket: MaybeTlsStream<TcpStream> = match uri.scheme_str() {
@@ -195,12 +210,12 @@ where
     .iter()
     .map(|header| header.to_str().unwrap())
     .collect::<String>();
-  Ok(json!({
-    "success": true,
-    "rid": rid,
-    "protocol": protocol,
-    "extensions": extensions
-  }))
+  Ok(CreateResponse {
+    success: true,
+    rid: Some(rid),
+    protocol: Some(protocol.to_string()),
+    extensions: Some(extensions),
+  })
 }
 
 #[derive(Deserialize)]
@@ -266,11 +281,23 @@ pub async fn op_ws_close(
   Ok(())
 }
 
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+pub enum NextEventResponse {
+  String(String),
+  Binary(Vec<u8>),
+  Close { code: u16, reason: String },
+  Ping,
+  Pong,
+  Error,
+  Closed,
+}
+
 pub async fn op_ws_next_event(
   state: Rc<RefCell<OpState>>,
   rid: ResourceId,
   _bufs: Option<ZeroCopyBuf>,
-) -> Result<Value, AnyError> {
+) -> Result<NextEventResponse, AnyError> {
   let resource = state
     .borrow_mut()
     .resource_table
@@ -281,37 +308,25 @@ pub async fn op_ws_next_event(
   let cancel = RcRef::map(resource, |r| &r.cancel);
   let val = rx.next().or_cancel(cancel).await?;
   let res = match val {
-    Some(Ok(Message::Text(text))) => json!({
-      "kind": "string",
-      "data": text
-    }),
+    Some(Ok(Message::Text(text))) => NextEventResponse::String(text),
     Some(Ok(Message::Binary(data))) => {
       // TODO(ry): don't use json to send binary data.
-      json!({
-        "kind": "binary",
-        "data": data
-      })
+      NextEventResponse::Binary(data)
     }
-    Some(Ok(Message::Close(Some(frame)))) => json!({
-      "kind": "close",
-      "data": {
-        "code": u16::from(frame.code),
-        "reason": frame.reason.as_ref()
-      }
-    }),
-    Some(Ok(Message::Close(None))) => json!({
-      "kind": "close",
-      "data": {
-        "code": 1005,
-        "reason": ""
-      }
-    }),
-    Some(Ok(Message::Ping(_))) => json!({ "kind": "ping" }),
-    Some(Ok(Message::Pong(_))) => json!({ "kind": "pong" }),
-    Some(Err(_)) => json!({ "kind": "error" }),
+    Some(Ok(Message::Close(Some(frame)))) => NextEventResponse::Close {
+      code: frame.code.into(),
+      reason: frame.reason.to_string(),
+    },
+    Some(Ok(Message::Close(None))) => NextEventResponse::Close {
+      code: 1005,
+      reason: String::new(),
+    },
+    Some(Ok(Message::Ping(_))) => NextEventResponse::Ping,
+    Some(Ok(Message::Pong(_))) => NextEventResponse::Pong,
+    Some(Err(_)) => NextEventResponse::Error,
     None => {
       state.borrow_mut().resource_table.close(rid).unwrap();
-      json!({ "kind": "closed" })
+      NextEventResponse::Closed
     }
   };
   Ok(res)