chore: minimize alloc for wasm crate

enmand · enmand · commit c29c10688a36 · 2024-08-25T23:55:25.000-03:00
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/crates/dwn-rs-core/src/events/emitter.rs b/crates/dwn-rs-core/src/events/emitter.rs
@@ -39,22 +39,34 @@ impl EventStreamer {
     }
 
     #[instrument]
-    pub async fn emit(&self, ns: String, evt: MessageEvent, indexes: MapValue) {
+    pub async fn emit(&self, ns: &str, evt: MessageEvent, indexes: MapValue) {
         if let Some(addr) = &self.0 {
-            let _ = addr.send(Emit { ns, evt, indexes }).await;
+            let _ = addr
+                .send(Emit {
+                    ns: ns.to_string(),
+                    evt,
+                    indexes,
+                })
+                .await;
         }
     }
 
     #[instrument]
     pub async fn subscribe(
         &self,
-        ns: String,
-        id: String,
+        ns: &str,
+        id: &str,
         listener: EventChannel,
     ) -> Result<Subscription, EventStreamError> {
         if let Some(addr) = &self.0 {
             trace!("subscribing to event stream");
-            let sub = addr.send(Subscribe { ns, id, listener }).await?;
+            let sub = addr
+                .send(Subscribe {
+                    ns: ns.to_string(),
+                    id: id.to_string(),
+                    listener,
+                })
+                .await?;
             return Ok(sub);
         }
 
diff --git a/crates/dwn-rs-core/src/events/subscription.rs b/crates/dwn-rs-core/src/events/subscription.rs
@@ -38,10 +38,13 @@ impl Handler<Event> for SubscriptionFn {
 
 impl SubscriptionFn {
     pub fn new(
-        id: String,
+        id: &str,
         f: Box<dyn Fn(String, MessageEvent, MapValue) + Send + Sync + 'static>,
     ) -> Self {
-        Self { id, f }
+        Self {
+            id: id.to_string(),
+            f,
+        }
     }
 
     #[cfg(target_arch = "wasm32")]
diff --git a/crates/dwn-rs-wasm/src/event_stream.rs b/crates/dwn-rs-wasm/src/event_stream.rs
@@ -1,3 +1,5 @@
+use alloc::{boxed::Box, string::String};
+
 use async_std::channel::unbounded;
 use dwn_rs_core::{
     emitter::EventStreamer, subscription::SubscriptionFn, MapValue,
@@ -44,21 +46,21 @@ impl EventStream {
     pub async fn emit(&self, tenant: &str, evt: &MessageEvent, indexes: IndexMap) {
         trace!("emitting event from wasm");
         let indextags = indexes.into();
-        self.events.emit(tenant.into(), evt.into(), indextags).await;
+        self.events.emit(tenant, evt.into(), indextags).await;
     }
 
     #[wasm_bindgen]
     pub async fn subscribe(
         &self,
         tenant: &str,
-        id: String,
+        id: &str,
         listener: js_sys::Function,
     ) -> Result<EventSubscription, JsError> {
         trace!("subscribing js function to event stream");
-        let sub = subscription_for_func(id.clone(), listener).await?.run();
+        let sub = subscription_for_func(id, listener).await?.run();
 
         self.events
-            .subscribe(tenant.into(), id, SubscriptionFn::channel(sub))
+            .subscribe(tenant, id, SubscriptionFn::channel(sub))
             .await
             .map_err(JsError::from)
             .map(|s| s.try_into().expect_throw("unable to convert subscription"))
@@ -67,7 +69,7 @@ impl EventStream {
 
 #[instrument]
 async fn subscription_for_func(
-    id: String,
+    id: &str,
     listener: js_sys::Function,
 ) -> Result<SubscriptionFn, JsError> {
     trace!("creating subscription for js function");
diff --git a/crates/dwn-rs-wasm/src/events.rs b/crates/dwn-rs-wasm/src/events.rs
@@ -1,3 +1,5 @@
+use alloc::boxed::Box;
+
 use dwn_rs_core::{MessageEvent as CoreMessageEvent, Subscription};
 use futures_util::FutureExt;
 use js_sys::{Object, Promise, Reflect};
@@ -19,19 +21,20 @@ extern "C" {
 
 impl From<&MessageEvent> for CoreMessageEvent {
     fn from(value: &MessageEvent) -> Self {
-        match serde_wasm_bindgen::from_value(value.into()) {
-            Ok(m) => m,
-            Err(e) => throw_str(&format!("unable to deserialize event: {:?}", e)),
+        if value.is_undefined() {
+            throw_str("MessageEvent is undefined");
         }
+
+        serde_wasm_bindgen::from_value(value.into()).expect_throw("unable to deserialize event")
     }
 }
 
 impl From<CoreMessageEvent> for MessageEvent {
     fn from(value: CoreMessageEvent) -> Self {
-        match value.serialize(&crate::ser::serializer()) {
-            Ok(m) => m.into(),
-            Err(e) => throw_str(&format!("unable to serialize event: {:?}", e)),
-        }
+        value
+            .serialize(&crate::ser::serializer())
+            .expect_throw("unable to serialize event")
+            .into()
     }
 }
 
@@ -47,10 +50,8 @@ impl TryFrom<Subscription> for EventSubscription {
             &Closure::once(Box::new(move || {
                 wasm_bindgen_futures::future_to_promise((value.close)().map(
                     |r| -> Result<JsValue, JsValue> {
-                        match r {
-                            Ok(_) => Ok(JsValue::UNDEFINED),
-                            Err(e) => throw_str(&format!("{:?}", e)),
-                        }
+                        r.expect_throw("unable to close subscription");
+                        Ok(JsValue::UNDEFINED)
                     },
                 ))
             }) as Box<dyn Fn() -> Promise>)
@@ -61,8 +62,8 @@ impl TryFrom<Subscription> for EventSubscription {
     }
 }
 
-impl std::fmt::Debug for MessageEvent {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl core::fmt::Debug for MessageEvent {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         f.debug_struct("MessageEvent").finish()
     }
 }
diff --git a/crates/dwn-rs-wasm/src/filter.rs b/crates/dwn-rs-wasm/src/filter.rs
@@ -1,5 +1,5 @@
 use alloc::string::{String, ToString};
-use wasm_bindgen::{prelude::*, throw_str};
+use wasm_bindgen::prelude::*;
 
 use dwn_rs_core::{
     filters::{FilterKey, FilterSet, Filters, ValueFilter},
@@ -50,44 +50,42 @@ impl From<Filter> for Filters {
 
 impl From<IndexMap> for (MapValue, MapValue) {
     fn from(value: IndexMap) -> Self {
-        match serde_wasm_bindgen::from_value::<MapValue>(value.into()) {
-            Ok(m) => m.into_iter().fold(
-                (MapValue::new(), MapValue::new()),
-                |(mut indexes, mut tags), (k, v)| {
-                    if let Some(tag) = k.strip_prefix("tag.") {
-                        tags.insert(tag.to_string(), v);
-                    } else {
-                        indexes.insert(k, v);
-                    }
+        let m = serde_wasm_bindgen::from_value::<MapValue>(value.into())
+            .expect_throw("unable to deserialize indexes");
 
-                    (indexes, tags)
-                },
-            ),
-            Err(e) => throw_str(&format!("unable to deserialize indexes: {:?}", e)),
-        }
+        m.into_iter().fold(
+            (MapValue::new(), MapValue::new()),
+            |(mut indexes, mut tags), (k, v)| {
+                if let Some(tag) = k.strip_prefix("tag.") {
+                    tags.insert(tag.to_string(), v);
+                } else {
+                    indexes.insert(k, v);
+                }
+
+                (indexes, tags)
+            },
+        )
     }
 }
 
 impl From<IndexMap> for MapValue {
     fn from(value: IndexMap) -> Self {
-        match serde_wasm_bindgen::from_value::<MapValue>(value.into()) {
-            Ok(m) => m,
-            Err(e) => throw_str(&format!("unable to deserialize indexes: {:?}", e)),
-        }
+        serde_wasm_bindgen::from_value::<MapValue>(value.into())
+            .expect_throw("unable to deserialize indexes")
     }
 }
 
 impl From<MapValue> for IndexMap {
     fn from(value: MapValue) -> Self {
-        match value.serialize(&crate::ser::serializer()) {
-            Ok(m) => m.into(),
-            Err(e) => throw_str(&format!("unable to serialize indexes: {:?}", e)),
-        }
+        value
+            .serialize(&crate::ser::serializer())
+            .expect_throw("unable to serialize indexes")
+            .into()
     }
 }
 
-impl std::fmt::Debug for IndexMap {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl core::fmt::Debug for IndexMap {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         f.debug_struct("IndexMap").finish()
     }
 }
diff --git a/crates/dwn-rs-wasm/src/query.rs b/crates/dwn-rs-wasm/src/query.rs
@@ -85,10 +85,7 @@ impl From<JSMessageSort> for MessageSort {
             return MessageSort::default();
         }
 
-        match serde_wasm_bindgen::from_value(value.into()) {
-            Ok(m) => m,
-            Err(_) => MessageSort::default(),
-        }
+        serde_wasm_bindgen::from_value(value.into()).unwrap_or_default()
     }
 }
 

Original file line number	Diff line number	Diff line change
`@@ -85,10 +85,7 @@ impl From<JSMessageSort> for MessageSort {`
`85`	`85`	`return MessageSort::default();`
`86`	`86`	`}`
`87`	`87`
`88`		`- match serde_wasm_bindgen::from_value(value.into()) {`
`89`		`- Ok(m) => m,`
`90`		`- Err(_) => MessageSort::default(),`
`91`		`- }`
	`88`	`+ serde_wasm_bindgen::from_value(value.into()).unwrap_or_default()`
`92`	`89`	`}`
`93`	`90`	`}`
`94`	`91`