chore(driver-adapters): unify napi/wasm logic for transaction.rs

query-engine/driver-adapters/src/lib.rs

@@ -12,9 +12,11 @@ pub(crate) mod error;
 pub(crate) mod proxy;
 pub(crate) mod queryable;
 pub(crate) mod send_future;
+pub(crate) mod transaction;
 pub(crate) mod types;
 
 pub use queryable::from_js;
+pub(crate) use transaction::JsTransaction;
 
 #[cfg(target_arch = "wasm32")]
 pub use wasm::JsObjectExtern as JsObject;

query-engine/driver-adapters/src/napi/mod.rs

@@ -4,7 +4,5 @@ mod async_js_function;
 mod conversion;
 mod error;
 mod result;
-mod transaction;
 
 pub(crate) use async_js_function::AsyncJsFunction;
-pub(crate) use transaction::JsTransaction;

query-engine/driver-adapters/src/proxy.rs

@@ -178,3 +178,4 @@ macro_rules! impl_send_sync_on_wasm {
 impl_send_sync_on_wasm!(TransactionProxy);
 impl_send_sync_on_wasm!(DriverProxy);
 impl_send_sync_on_wasm!(CommonProxy);
+impl_send_sync_on_wasm!(JsTransaction);

query-engine/driver-adapters/src/send_future.rs

@@ -11,8 +11,6 @@ use futures::Future;
 #[pin_project::pin_project]
 pub struct SendFuture<F: Future>(#[pin] pub F);
 
-unsafe impl<F: Future> Send for SendFuture<F> {}
-
 impl<F: Future> Future for SendFuture<F> {
     type Output = F::Output;
 
@@ -22,3 +20,8 @@ impl<F: Future> Future for SendFuture<F> {
         future.poll(cx)
     }
 }
+
+// Note: on Napi.rs, we require the underlying future to be `Send`.
+// On Wasm, that's currently not possible.
+#[cfg(target_arch = "wasm32")]
+unsafe impl<F: Future> Send for SendFuture<F> {}

query-engine/driver-adapters/src/wasm/transaction.rs → query-engine/driver-adapters/src/transaction.rs

@@ -1,16 +1,14 @@
 use async_trait::async_trait;
-use js_sys::Object as JsObject;
 use metrics::decrement_gauge;
 use quaint::{
     connector::{IsolationLevel, Transaction as QuaintTransaction},
     prelude::{Query as QuaintQuery, Queryable, ResultSet},
     Value,
 };
-use wasm_bindgen::JsCast;
 
-use super::from_js::FromJsValue;
 use crate::proxy::{TransactionOptions, TransactionProxy};
-use crate::{proxy::CommonProxy, queryable::JsBaseQueryable, send_future::SendFuture, JsObjectExtern};
+use crate::{proxy::CommonProxy, queryable::JsBaseQueryable, send_future::SendFuture};
+use crate::{JsObject, JsResult};
 
 // Wrapper around JS transaction objects that implements Queryable
 // and quaint::Transaction. Can be used in place of quaint transaction,
@@ -35,17 +33,6 @@ impl JsTransaction {
     }
 }
 
-impl FromJsValue for JsTransaction {
-    fn from_js_value(value: wasm_bindgen::prelude::JsValue) -> Result<Self, wasm_bindgen::prelude::JsValue> {
-        let object: JsObjectExtern = value.dyn_into::<JsObject>()?.unchecked_into();
-        let common_proxy = CommonProxy::new(&object)?;
-        let base = JsBaseQueryable::new(common_proxy);
-        let tx_proxy = TransactionProxy::new(&object)?;
-
-        Ok(Self::new(base, tx_proxy))
-    }
-}
-
 #[async_trait]
 impl QuaintTransaction for JsTransaction {
     async fn commit(&self) -> quaint::Result<()> {
@@ -132,6 +119,29 @@ impl Queryable for JsTransaction {
     }
 }
 
-// Assume the proxy object will not be sent to service workers, we can unsafe impl Send + Sync.
-unsafe impl Send for JsTransaction {}
-unsafe impl Sync for JsTransaction {}
+#[cfg(target_arch = "wasm32")]
+impl super::wasm::FromJsValue for JsTransaction {
+    fn from_js_value(value: wasm_bindgen::prelude::JsValue) -> JsResult<Self> {
+        use wasm_bindgen::JsCast;
+
+        let object = value.dyn_into::<JsObject>()?;
+        let common_proxy = CommonProxy::new(&object)?;
+        let base = JsBaseQueryable::new(common_proxy);
+        let tx_proxy = TransactionProxy::new(&object)?;
+
+        Ok(Self::new(base, tx_proxy))
+    }
+}
+
+/// Implementing unsafe `from_napi_value` allows retrieving a threadsafe `JsTransaction` in `DriverProxy`
+/// while keeping derived futures `Send`.
+#[cfg(not(target_arch = "wasm32"))]
+impl ::napi::bindgen_prelude::FromNapiValue for JsTransaction {
+    unsafe fn from_napi_value(env: napi::sys::napi_env, napi_val: napi::sys::napi_value) -> JsResult<Self> {
+        let object = JsObject::from_napi_value(env, napi_val)?;
+        let common_proxy = CommonProxy::new(&object)?;
+        let tx_proxy = TransactionProxy::new(&object)?;
+
+        Ok(Self::new(JsBaseQueryable::new(common_proxy), tx_proxy))
+    }
+}

query-engine/driver-adapters/src/wasm/from_js.rs

@@ -1,7 +1,7 @@
 use serde::de::DeserializeOwned;
 use wasm_bindgen::JsValue;
 
-pub trait FromJsValue: Sized {
+pub(crate) trait FromJsValue: Sized {
     fn from_js_value(value: JsValue) -> Result<Self, JsValue>;
 }
 

query-engine/driver-adapters/src/wasm/mod.rs

@@ -5,8 +5,7 @@ mod error;
 mod from_js;
 mod js_object_extern;
 mod result;
-mod transaction;
 
 pub(crate) use async_js_function::AsyncJsFunction;
+pub(crate) use from_js::FromJsValue;
 pub use js_object_extern::JsObjectExtern;
-pub(crate) use transaction::JsTransaction;