From eca83fc9b45ab1e5a73bd7b13b05ee42ab1a4dcc Mon Sep 17 00:00:00 2001
From: Leo Kettmeir <crowlkats@toaxl.com>
Date: Thu, 17 Oct 2024 12:05:38 -0700
Subject: refactor(ext/web): use concrete error types (#26185)

---
 runtime/errors.rs                    | 75 +++++++++++++++++++++++++++++++++++-
 runtime/ops/web_worker.rs            |  1 +
 runtime/ops/web_worker/sync_fetch.rs |  2 +-
 runtime/ops/worker_host.rs           |  2 +-
 4 files changed, 77 insertions(+), 3 deletions(-)

(limited to 'runtime')

diff --git a/runtime/errors.rs b/runtime/errors.rs
index ffcc1c119..99de6beb0 100644
--- a/runtime/errors.rs
+++ b/runtime/errors.rs
@@ -28,6 +28,11 @@ use deno_kv::KvError;
 use deno_kv::KvMutationError;
 use deno_net::ops::NetError;
 use deno_tls::TlsError;
+use deno_web::BlobError;
+use deno_web::CompressionError;
+use deno_web::MessagePortError;
+use deno_web::StreamResourceError;
+use deno_web::WebError;
 use deno_webstorage::WebStorageError;
 use std::env;
 use std::error::Error;
@@ -169,6 +174,61 @@ pub fn get_nix_error_class(error: &nix::Error) -> &'static str {
   }
 }
 
+fn get_web_error_class(e: &WebError) -> &'static str {
+  match e {
+    WebError::Base64Decode => "DOMExceptionInvalidCharacterError",
+    WebError::InvalidEncodingLabel(_) => "RangeError",
+    WebError::BufferTooLong => "TypeError",
+    WebError::ValueTooLarge => "RangeError",
+    WebError::BufferTooSmall => "RangeError",
+    WebError::DataInvalid => "TypeError",
+    WebError::DataError(_) => "Error",
+  }
+}
+
+fn get_web_compression_error_class(e: &CompressionError) -> &'static str {
+  match e {
+    CompressionError::UnsupportedFormat => "TypeError",
+    CompressionError::ResourceClosed => "TypeError",
+    CompressionError::IoTypeError(_) => "TypeError",
+    CompressionError::Io(e) => get_io_error_class(e),
+  }
+}
+
+fn get_web_message_port_error_class(e: &MessagePortError) -> &'static str {
+  match e {
+    MessagePortError::InvalidTransfer => "TypeError",
+    MessagePortError::NotReady => "TypeError",
+    MessagePortError::TransferSelf => "TypeError",
+    MessagePortError::Canceled(e) => {
+      let io_err: io::Error = e.to_owned().into();
+      get_io_error_class(&io_err)
+    }
+    MessagePortError::Resource(e) => get_error_class_name(e).unwrap_or("Error"),
+  }
+}
+
+fn get_web_stream_resource_error_class(
+  e: &StreamResourceError,
+) -> &'static str {
+  match e {
+    StreamResourceError::Canceled(e) => {
+      let io_err: io::Error = e.to_owned().into();
+      get_io_error_class(&io_err)
+    }
+    StreamResourceError::Js(_) => "TypeError",
+  }
+}
+
+fn get_web_blob_error_class(e: &BlobError) -> &'static str {
+  match e {
+    BlobError::BlobPartNotFound => "TypeError",
+    BlobError::SizeLargerThanBlobPart => "TypeError",
+    BlobError::BlobURLsNotSupported => "TypeError",
+    BlobError::Url(_) => "Error",
+  }
+}
+
 fn get_ffi_repr_error_class(e: &ReprError) -> &'static str {
   match e {
     ReprError::InvalidOffset => "TypeError",
@@ -382,8 +442,21 @@ fn get_net_map_error(error: &deno_net::io::MapError) -> &'static str {
 pub fn get_error_class_name(e: &AnyError) -> Option<&'static str> {
   deno_core::error::get_custom_error_class(e)
     .or_else(|| deno_webgpu::error::get_error_class_name(e))
-    .or_else(|| deno_web::get_error_class_name(e))
     .or_else(|| deno_websocket::get_network_error_class_name(e))
+    .or_else(|| e.downcast_ref::<WebError>().map(get_web_error_class))
+    .or_else(|| {
+      e.downcast_ref::<CompressionError>()
+        .map(get_web_compression_error_class)
+    })
+    .or_else(|| {
+      e.downcast_ref::<MessagePortError>()
+        .map(get_web_message_port_error_class)
+    })
+    .or_else(|| {
+      e.downcast_ref::<StreamResourceError>()
+        .map(get_web_stream_resource_error_class)
+    })
+    .or_else(|| e.downcast_ref::<BlobError>().map(get_web_blob_error_class))
     .or_else(|| e.downcast_ref::<IRError>().map(|_| "TypeError"))
     .or_else(|| e.downcast_ref::<ReprError>().map(get_ffi_repr_error_class))
     .or_else(|| {
diff --git a/runtime/ops/web_worker.rs b/runtime/ops/web_worker.rs
index 0ed76ebd5..e28bf2192 100644
--- a/runtime/ops/web_worker.rs
+++ b/runtime/ops/web_worker.rs
@@ -50,6 +50,7 @@ async fn op_worker_recv_message(
     .recv(state.clone())
     .or_cancel(handle.cancel)
     .await?
+    .map_err(|e| e.into())
 }
 
 #[op2(fast)]
diff --git a/runtime/ops/web_worker/sync_fetch.rs b/runtime/ops/web_worker/sync_fetch.rs
index cdb151a86..87fc55840 100644
--- a/runtime/ops/web_worker/sync_fetch.rs
+++ b/runtime/ops/web_worker/sync_fetch.rs
@@ -134,7 +134,7 @@ pub fn op_worker_sync_fetch(
 
                 let mime_type = mime_type_essence(&blob.media_type);
 
-                let body = blob.read_all().await?;
+                let body = blob.read_all().await;
 
                 (Bytes::from(body), Some(mime_type), script)
               }
diff --git a/runtime/ops/worker_host.rs b/runtime/ops/worker_host.rs
index 61e5ef3e0..d85541d51 100644
--- a/runtime/ops/worker_host.rs
+++ b/runtime/ops/worker_host.rs
@@ -359,7 +359,7 @@ async fn op_host_recv_message(
       }
       Ok(ret)
     }
-    Ok(Err(err)) => Err(err),
+    Ok(Err(err)) => Err(err.into()),
     Err(_) => {
       // The worker was terminated.
       Ok(None)
-- 
cgit v1.2.3