Added wasm worker dispatcher and single threaded support, compilation works, runtime fails at handshake

Signed-off-by: Aditya <[email protected]>

Author: Aditya1404Sal

Cargo.lock

@@ -52,6 +52,8 @@ async-std = { workspace = true, optional = true }
 smol = { workspace = true, optional = true }
 tokio = { workspace = true, optional = true, features = ["sync","rt"]}
 tokio-util = { workspace = true }
+async-lock = "2.5.0"
+once_cell = "1.21.3"
 
 # TLS
 native-tls = { version = "0.2.10", optional = true }

sqlx-core/Cargo.toml

@@ -199,11 +199,6 @@ pub async fn connect_tcp<Ws: WithSocket>(
             .await);
     }
 
-    #[cfg(target_arch = "wasm32")]
-    {
-        todo!("outer socket impl")
-    }
-
     cfg_if! {
         if #[cfg(feature = "_rt-async-io")] {
             Ok(with_socket.with_socket(connect_tcp_async_io(host, port).await?).await)

sqlx-core/src/net/socket/mod.rs

@@ -347,7 +347,23 @@ impl<DB: Database> PoolInner<DB> {
 
             // result here is `Result<Result<C, Error>, TimeoutError>`
             // if this block does not return, sleep for the backoff timeout and try again
+            eprintln!(
+                "pool: attempting connect (deadline in {}ms, current size={})",
+                timeout.as_millis(),
+                self.size()
+            );
+
             let res = crate::rt::timeout(timeout, connect_options.connect()).await;
+            if let Ok(Ok(_)) = &res {
+                eprintln!("pool: connect attempt succeeded");
+            } else if let Ok(Err(e)) = &res {
+                eprintln!("pool: connect attempt returned error: {:?}", e);
+            } else if res.is_err() {
+                eprintln!(
+                    "pool: connect attempt timed out after {}ms",
+                    timeout.as_millis()
+                );
+            }
             match res {
                 // successfully established connection
                 Ok(Ok(mut raw)) => {

sqlx-core/src/pool/inner.rs

@@ -15,6 +15,9 @@ pub mod rt_tokio;
 #[cfg(target_arch = "wasm32")]
 pub mod rt_wasip3;
 
+#[cfg(target_arch = "wasm32")]
+pub mod wasm_worker;
+
 #[derive(Debug, thiserror::Error)]
 #[error("operation timed out")]
 pub struct TimeoutError;
@@ -38,6 +41,30 @@ pub async fn timeout<F: Future>(duration: Duration, f: F) -> Result<F::Output, T
     #[cfg(debug_assertions)]
     let f = Box::pin(f);
 
+    // wasm: avoid requiring a Tokio runtime handle. Race the future against
+    // a wasip3 monotonic sleep using futures::select so the function works
+    // under the wasip3 executor which doesn't expose a Tokio Handle.
+    #[cfg(target_arch = "wasm32")]
+    {
+        use futures_util::{future::FutureExt, pin_mut, select};
+        // `sleep` is the runtime-agnostic sleep in this same `rt` module:
+        use crate::rt::sleep;
+
+        // fuse so select! can safely poll them
+        let mut fut = f.fuse();
+        let mut timer = sleep(duration).fuse();
+
+        // pin them on the stack (avoids requiring F: Unpin)
+        pin_mut!(fut, timer);
+
+        // select! is an expression — return it
+        return select! {
+            res = fut => Ok(res),
+            _ = timer => Err(TimeoutError),
+        };
+    }
+
+    // Native: if Tokio is enabled and a handle is available, delegate to it.
     #[cfg(feature = "_rt-tokio")]
     if rt_tokio::available() {
         return tokio::time::timeout(duration, f)
@@ -171,11 +198,20 @@ pub fn test_block_on<F: Future>(f: F) -> F::Output {
 
     #[cfg(any(feature = "_rt-tokio", target_arch = "wasm32"))]
     {
-        return tokio::runtime::Builder::new_current_thread()
+        let rt = tokio::runtime::Builder::new_current_thread()
             .enable_all()
             .build()
-            .expect("failed to start Tokio runtime")
-            .block_on(f);
+            .expect("failed to start Tokio runtime");
+
+        #[cfg(target_arch = "wasm32")]
+        {
+            return rt.block_on(async { tokio::task::LocalSet::new().run_until(f).await });
+        }
+
+        #[cfg(not(target_arch = "wasm32"))]
+        {
+            return rt.block_on(f);
+        }
     }
 
     #[cfg(all(