@temporalio/core-bridge 1.11.8 → 1.12.0

package/src/helpers/properties.rs

@@ -0,0 +1,71 @@
+use neon::prelude::*;
+
+use super::{AppendFieldContext as _, BridgeError, BridgeResult, TryFromJs, TryIntoJs};
+
+/// Extension trait for `JsObject`.
+pub trait ObjectExt: Object {
+    /// Get a property from a JS Object, converting it to a Rust value using `TryFromJs`.
+    ///
+    /// Type errors will be reported with `field` set to the name of the property being
+    /// accessed; it is expected that caller will prepend any additional path components
+    /// that led to this object, to help identify the object that failed.
+    fn get_property_into<'cx, C: Context<'cx>, T: TryFromJs>(
+        &self,
+        cx: &mut C,
+        key: &str,
+    ) -> BridgeResult<T> {
+        let value = self.get_value(cx, key)?;
+        if value.is_a::<JsUndefined, _>(cx) {
+            return Err(BridgeError::TypeError {
+                message: format!("Missing property '{key}'"),
+                field: Some(key.to_string()),
+            });
+        }
+        <T>::try_from_js(cx, value).field(key)
+    }
+
+    /// Set a property on a JS Object, converting it from a Rust value using `TryIntoJs`.
+    fn set_property_from<'cx, C: Context<'cx>, T: TryIntoJs>(
+        &self,
+        cx: &mut C,
+        key: &str,
+        value: T,
+    ) -> NeonResult<()> {
+        let key = cx.string(key);
+        let value = value.try_into_js(cx)?;
+        self.set(cx, key, value)?;
+        Ok(())
+    }
+
+    /// Set a property on a JS Object, converting it from a Rust value using `TryIntoJs`.
+    fn set_property<'cx, C: Context<'cx>, T: Value>(
+        &self,
+        cx: &mut C,
+        key: &str,
+        value: Handle<'cx, T>,
+    ) -> NeonResult<()> {
+        let key = cx.string(key);
+        self.set(cx, key, value)?;
+        Ok(())
+    }
+}
+
+impl ObjectExt for JsObject {}
+impl ObjectExt for JsError {}
+
+/// Extension trait for `FunctionContext` that adds a method to get an argument and
+/// convert it to a value using `TryFromJs`.
+///
+/// Type errors will be reported with field name `args[index]`; it is expected that
+/// caller will prepend the function name to the error message's `field` to help identify
+/// the function that failed.
+pub trait FunctionContextExt {
+    fn argument_into<T: TryFromJs>(&mut self, index: usize) -> BridgeResult<T>;
+}
+
+impl FunctionContextExt for FunctionContext<'_> {
+    fn argument_into<T: TryFromJs>(&mut self, index: usize) -> BridgeResult<T> {
+        let value = self.argument::<JsValue>(index)?;
+        <T>::try_from_js(self, value).field(format!("args[{index}]").as_str())
+    }
+}

package/src/helpers/try_from_js.rs

@@ -0,0 +1,213 @@
+use std::{collections::HashMap, net::SocketAddr, time::Duration};
+
+use neon::{
+    handle::Handle,
+    object::Object,
+    prelude::Context,
+    types::{
+        JsArray, JsBoolean, JsBuffer, JsNull, JsNumber, JsObject, JsString, JsUndefined, JsValue,
+        Value, buffer::TypedArray,
+    },
+};
+use temporal_sdk_core::Url;
+
+use super::{BridgeError, BridgeResult};
+
+/// Trait for Rust types that can be created from JavaScript values, possibly throwing an error.
+pub trait TryFromJs: Sized {
+    fn try_from_js<'cx, 'b>(
+        cx: &mut impl Context<'cx>,
+        js_value: Handle<'b, JsValue>,
+    ) -> BridgeResult<Self>;
+}
+
+// TryFromJs implementations for primitives and other basic types //////////////////////////////////
+
+impl TryFromJs for () {
+    fn try_from_js<'cx, 'b>(
+        cx: &mut impl Context<'cx>,
+        js_value: Handle<'b, JsValue>,
+    ) -> BridgeResult<Self> {
+        // Make sure we are not getting something where we expect nothing
+        let _ = js_value.downcast::<JsUndefined, _>(cx)?;
+        Ok(())
+    }
+}
+
+impl TryFromJs for String {
+    fn try_from_js<'cx, 'b>(
+        cx: &mut impl Context<'cx>,
+        js_value: Handle<'b, JsValue>,
+    ) -> BridgeResult<Self> {
+        Ok(js_value.downcast::<JsString, _>(cx)?.value(cx))
+    }
+}
+
+impl TryFromJs for bool {
+    fn try_from_js<'cx, 'b>(
+        cx: &mut impl Context<'cx>,
+        js_value: Handle<'b, JsValue>,
+    ) -> BridgeResult<Self> {
+        Ok(js_value.downcast::<JsBoolean, _>(cx)?.value(cx))
+    }
+}
+
+impl TryFromJs for u16 {
+    fn try_from_js<'cx, 'b>(
+        cx: &mut impl Context<'cx>,
+        js_value: Handle<'b, JsValue>,
+    ) -> BridgeResult<Self> {
+        #[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
+        Ok(js_value.downcast::<JsNumber, _>(cx)?.value(cx) as Self)
+    }
+}
+
+#[allow(clippy::cast_possible_truncation)]
+impl TryFromJs for i32 {
+    fn try_from_js<'cx, 'b>(
+        cx: &mut impl Context<'cx>,
+        js_value: Handle<'b, JsValue>,
+    ) -> BridgeResult<Self> {
+        Ok(js_value.downcast::<JsNumber, _>(cx)?.value(cx) as Self)
+    }
+}
+
+#[allow(clippy::cast_possible_truncation)]
+impl TryFromJs for f32 {
+    fn try_from_js<'cx, 'b>(
+        cx: &mut impl Context<'cx>,
+        js_value: Handle<'b, JsValue>,
+    ) -> BridgeResult<Self> {
+        Ok(js_value.downcast::<JsNumber, _>(cx)?.value(cx) as Self)
+    }
+}
+
+#[allow(clippy::cast_possible_truncation)]
+impl TryFromJs for u64 {
+    fn try_from_js<'cx, 'b>(
+        cx: &mut impl Context<'cx>,
+        js_value: Handle<'b, JsValue>,
+    ) -> BridgeResult<Self> {
+        #[allow(clippy::cast_sign_loss)]
+        Ok(js_value.downcast::<JsNumber, _>(cx)?.value(cx) as Self)
+    }
+}
+
+impl TryFromJs for f64 {
+    fn try_from_js<'cx, 'b>(
+        cx: &mut impl Context<'cx>,
+        js_value: Handle<'b, JsValue>,
+    ) -> BridgeResult<Self> {
+        Ok(js_value.downcast::<JsNumber, _>(cx)?.value(cx))
+    }
+}
+
+impl TryFromJs for usize {
+    fn try_from_js<'cx, 'b>(
+        cx: &mut impl Context<'cx>,
+        js_value: Handle<'b, JsValue>,
+    ) -> BridgeResult<Self> {
+        #[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
+        Ok(js_value.downcast::<JsNumber, _>(cx)?.value(cx) as Self)
+    }
+}
+
+impl TryFromJs for Duration {
+    fn try_from_js<'cx, 'b>(
+        cx: &mut impl Context<'cx>,
+        js_value: Handle<'b, JsValue>,
+    ) -> BridgeResult<Self> {
+        #[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
+        Ok(Self::from_millis(
+            js_value.downcast::<JsNumber, _>(cx)?.value(cx) as u64,
+        ))
+    }
+}
+
+impl<T: TryFromJs> TryFromJs for Option<T> {
+    fn try_from_js<'cx, 'b>(
+        cx: &mut impl Context<'cx>,
+        js_value: Handle<'b, JsValue>,
+    ) -> BridgeResult<Self> {
+        if js_value.is_a::<JsNull, _>(cx) {
+            Ok(None)
+        } else {
+            Ok(Some(T::try_from_js(cx, js_value)?))
+        }
+    }
+}
+
+impl TryFromJs for Vec<u8> {
+    fn try_from_js<'cx, 'b>(
+        cx: &mut impl Context<'cx>,
+        js_value: Handle<'b, JsValue>,
+    ) -> BridgeResult<Self> {
+        Ok(js_value.downcast::<JsBuffer, _>(cx)?.as_slice(cx).to_vec())
+    }
+}
+
+impl<T: TryFromJs> TryFromJs for Vec<T> {
+    fn try_from_js<'cx, 'b>(
+        cx: &mut impl Context<'cx>,
+        js_value: Handle<'b, JsValue>,
+    ) -> BridgeResult<Self> {
+        let array = js_value.downcast::<JsArray, _>(cx)?;
+        let len = array.len(cx);
+        let mut result = Self::with_capacity(len as usize);
+
+        for i in 0..len {
+            let value = array.get_value(cx, i)?;
+            result.push(T::try_from_js(cx, value)?);
+        }
+        Ok(result)
+    }
+}
+
+#[allow(clippy::implicit_hasher)]
+impl<T: TryFromJs> TryFromJs for HashMap<String, T> {
+    fn try_from_js<'cx, 'b>(
+        cx: &mut impl Context<'cx>,
+        js_value: Handle<'b, JsValue>,
+    ) -> BridgeResult<Self> {
+        let obj = js_value.downcast::<JsObject, _>(cx)?;
+        let props = obj.get_own_property_names(cx)?.to_vec(cx)?;
+
+        let mut map = Self::new();
+        for key_handle in props {
+            let key = key_handle.to_string(cx)?.value(cx);
+            let value = obj.get_value(cx, key_handle)?;
+            map.insert(key, T::try_from_js(cx, value)?);
+        }
+        Ok(map)
+    }
+}
+
+impl TryFromJs for SocketAddr {
+    fn try_from_js<'cx, 'b>(
+        cx: &mut impl Context<'cx>,
+        js_value: Handle<'b, JsValue>,
+    ) -> BridgeResult<Self> {
+        let addr = js_value.downcast::<JsString, _>(cx)?;
+        addr.value(cx)
+            .parse::<Self>()
+            .map_err(|e| BridgeError::TypeError {
+                field: None,
+                message: e.to_string(),
+            })
+    }
+}
+
+impl TryFromJs for Url {
+    fn try_from_js<'cx, 'b>(
+        cx: &mut impl Context<'cx>,
+        js_value: Handle<'b, JsValue>,
+    ) -> BridgeResult<Self> {
+        let url = js_value.downcast::<JsString, _>(cx)?;
+        url.value(cx)
+            .parse::<Self>()
+            .map_err(|e| BridgeError::TypeError {
+                field: None,
+                message: e.to_string(),
+            })
+    }
+}

package/src/helpers/try_into_js.rs

@@ -0,0 +1,129 @@
+use std::{
+    sync::Arc,
+    time::{Duration, SystemTime, UNIX_EPOCH},
+};
+
+use neon::{
+    object::Object,
+    prelude::Context,
+    result::JsResult,
+    types::{
+        JsArray, JsBigInt, JsBoolean, JsBuffer, JsNumber, JsString, JsUndefined, JsValue, Value,
+    },
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+/// Trait for types that can be converted to JavaScript values, possibly throwing an error.
+pub trait TryIntoJs {
+    type Output: Value;
+    fn try_into_js<'cx>(self, cx: &mut impl Context<'cx>) -> JsResult<'cx, Self::Output>;
+}
+
+// TryIntoJs implementations for primitives and other basic types //////////////////////////////////
+
+impl TryIntoJs for bool {
+    type Output = JsBoolean;
+    fn try_into_js<'a>(self, cx: &mut impl Context<'a>) -> JsResult<'a, JsBoolean> {
+        Ok(cx.boolean(self))
+    }
+}
+
+impl TryIntoJs for u32 {
+    type Output = JsNumber;
+    fn try_into_js<'a>(self, cx: &mut impl Context<'a>) -> JsResult<'a, JsNumber> {
+        Ok(cx.number(self))
+    }
+}
+
+impl TryIntoJs for String {
+    type Output = JsString;
+    fn try_into_js<'a>(self, cx: &mut impl Context<'a>) -> JsResult<'a, JsString> {
+        Ok(cx.string(self.as_str()))
+    }
+}
+
+impl TryIntoJs for &str {
+    type Output = JsString;
+    fn try_into_js<'a>(self, cx: &mut impl Context<'a>) -> JsResult<'a, JsString> {
+        Ok(cx.string(self))
+    }
+}
+
+impl<T: TryIntoJs> TryIntoJs for Vec<T> {
+    type Output = JsArray;
+
+    fn try_into_js<'a>(self, cx: &mut impl Context<'a>) -> JsResult<'a, JsArray> {
+        let array = cx.empty_array();
+        for (i, item) in self.into_iter().enumerate() {
+            let item = item.try_into_js(cx)?;
+            #[allow(clippy::cast_possible_truncation)]
+            array.set(cx, i as u32, item)?;
+        }
+        Ok(array)
+    }
+}
+
+impl TryIntoJs for Vec<u8> {
+    type Output = JsBuffer;
+    fn try_into_js<'a>(self, cx: &mut impl Context<'a>) -> JsResult<'a, JsBuffer> {
+        JsBuffer::from_slice(cx, &self)
+    }
+}
+
+impl TryIntoJs for &[u8] {
+    type Output = JsBuffer;
+    fn try_into_js<'a>(self, cx: &mut impl Context<'a>) -> JsResult<'a, JsBuffer> {
+        JsBuffer::from_slice(cx, self)
+    }
+}
+
+impl TryIntoJs for SystemTime {
+    type Output = JsBigInt;
+    fn try_into_js<'a>(self, cx: &mut impl Context<'a>) -> JsResult<'a, JsBigInt> {
+        let nanos = self
+            .duration_since(UNIX_EPOCH)
+            .unwrap_or(Duration::ZERO)
+            .as_nanos();
+        Ok(JsBigInt::from_u128(cx, nanos))
+    }
+}
+
+impl<T: TryIntoJs> TryIntoJs for Option<T> {
+    // Output really is (T::Output | JsNull), hence JsValue
+    type Output = JsValue;
+    fn try_into_js<'a>(self, cx: &mut impl Context<'a>) -> JsResult<'a, JsValue> {
+        if let Some(value) = self {
+            Ok(value.try_into_js(cx)?.upcast())
+        } else {
+            Ok(cx.null().upcast())
+        }
+    }
+}
+
+impl<T: TryIntoJs + Clone> TryIntoJs for Arc<T> {
+    type Output = T::Output;
+    fn try_into_js<'a>(self, cx: &mut impl Context<'a>) -> JsResult<'a, T::Output> {
+        self.as_ref().clone().try_into_js(cx)
+    }
+}
+
+impl TryIntoJs for () {
+    type Output = JsUndefined;
+    fn try_into_js<'a>(self, cx: &mut impl Context<'a>) -> JsResult<'a, JsUndefined> {
+        Ok(cx.undefined())
+    }
+}
+
+impl<T0: TryIntoJs, T1: TryIntoJs> TryIntoJs for (T0, T1) {
+    type Output = JsArray;
+    fn try_into_js<'a>(self, cx: &mut impl Context<'a>) -> JsResult<'a, JsArray> {
+        let v0 = self.0.try_into_js(cx)?;
+        let v1 = self.1.try_into_js(cx)?;
+
+        let array = cx.empty_array();
+        array.set(cx, 0, v0)?;
+        array.set(cx, 1, v1)?;
+        Ok(array)
+    }
+}

package/src/lib.rs

@@ -1,47 +1,35 @@
-mod conversions;
-mod errors;
-mod helpers;
+#![warn(
+    clippy::pedantic,
+    clippy::nursery,
+    clippy::cargo,
+    clippy::perf,
+    clippy::style
+)]
+#![allow(
+    clippy::missing_errors_doc,
+    clippy::too_long_first_doc_paragraph,
+    clippy::option_if_let_else,
+    clippy::multiple_crate_versions,
+    clippy::significant_drop_tightening
+)]
+
+pub mod helpers;
+
+mod client;
+mod logs;
+mod metrics;
 mod runtime;
 mod testing;
 mod worker;
 
-use crate::runtime::*;
-use crate::worker::*;
-use neon::prelude::*;
-use testing::*;
-
 #[neon::main]
-fn main(mut cx: ModuleContext) -> NeonResult<()> {
-    cx.export_function("getTimeOfDay", get_time_of_day)?;
-    cx.export_function("newRuntime", runtime_new)?;
-    cx.export_function("newClient", client_new)?;
-    cx.export_function("clientUpdateHeaders", client_update_headers)?;
-    cx.export_function("clientUpdateApiKey", client_update_api_key)?;
-    cx.export_function("newWorker", worker_new)?;
-    cx.export_function("newReplayWorker", replay_worker_new)?;
-    cx.export_function("pushHistory", push_history)?;
-    cx.export_function("closeHistoryStream", close_history_stream)?;
-    cx.export_function("workerInitiateShutdown", worker_initiate_shutdown)?;
-    cx.export_function("workerFinalizeShutdown", worker_finalize_shutdown)?;
-    cx.export_function("clientClose", client_close)?;
-    cx.export_function("runtimeShutdown", runtime_shutdown)?;
-    cx.export_function("pollLogs", poll_logs)?;
-    cx.export_function(
-        "workerPollWorkflowActivation",
-        worker_poll_workflow_activation,
-    )?;
-    cx.export_function("workerPollActivityTask", worker_poll_activity_task)?;
-    cx.export_function(
-        "workerCompleteWorkflowActivation",
-        worker_complete_workflow_activation,
-    )?;
-    cx.export_function("workerCompleteActivityTask", worker_complete_activity_task)?;
-    cx.export_function(
-        "workerRecordActivityHeartbeat",
-        worker_record_activity_heartbeat,
-    )?;
-    cx.export_function("startEphemeralServer", start_ephemeral_server)?;
-    cx.export_function("shutdownEphemeralServer", shutdown_ephemeral_server)?;
-    cx.export_function("getEphemeralServerTarget", get_ephemeral_server_target)?;
+fn main(mut cx: neon::prelude::ModuleContext) -> neon::prelude::NeonResult<()> {
+    client::init(&mut cx)?;
+    logs::init(&mut cx)?;
+    metrics::init(&mut cx)?;
+    runtime::init(&mut cx)?;
+    testing::init(&mut cx)?;
+    worker::init(&mut cx)?;
+
     Ok(())
 }

package/src/logs.rs

@@ -0,0 +1,111 @@
+use std::{
+    collections::HashMap,
+    time::{Duration, SystemTime, UNIX_EPOCH},
+};
+
+use neon::prelude::*;
+
+use serde::{Serialize, ser::SerializeMap as _};
+use temporal_sdk_core::api::telemetry::CoreLog;
+
+use bridge_macros::js_function;
+
+use crate::helpers::{BridgeError, BridgeResult, IntoThrow, JsonString, TryIntoJs};
+
+pub fn init(cx: &mut neon::prelude::ModuleContext) -> neon::prelude::NeonResult<()> {
+    cx.export_function("getTimeOfDay", get_time_of_day)?;
+
+    Ok(())
+}
+
+/// Helper to get the current time in nanosecond resolution. Nano seconds timestamps are
+/// used to precisely sort logs emitted from the Workflow Context, main thread, and Core.
+#[js_function]
+pub fn get_time_of_day() -> BridgeResult<SystemTime> {
+    Ok(SystemTime::now())
+}
+
+#[derive(Debug, Clone, Serialize)]
+pub struct LogEntry {
+    pub target: String,
+    pub message: String,
+    pub timestamp: String, // u128 as a string - JSON doesn't support u128 numbers
+    pub level: String,
+
+    #[serde(serialize_with = "serialize_map_as_camel_case")]
+    pub fields: HashMap<String, serde_json::Value>,
+    pub span_contexts: Vec<String>,
+}
+
+impl TryFrom<CoreLog> for JsonString<LogEntry> {
+    type Error = BridgeError;
+
+    fn try_from(core_log: CoreLog) -> BridgeResult<Self> {
+        let timestamp = core_log
+            .timestamp
+            .duration_since(UNIX_EPOCH)
+            .unwrap_or(Duration::ZERO)
+            .as_nanos();
+
+        Self::try_from_value(LogEntry {
+            target: core_log.target,
+            message: core_log.message,
+            timestamp: timestamp.to_string(),
+            level: core_log.level.to_string(),
+            fields: core_log.fields,
+            span_contexts: core_log.span_contexts,
+        })
+    }
+}
+
+/// Serialize a map, converting keys to camel case.
+fn serialize_map_as_camel_case<S>(
+    value: &HashMap<String, serde_json::Value>,
+    serializer: S,
+) -> Result<S::Ok, S::Error>
+where
+    S: serde::Serializer,
+{
+    let mut map = serializer.serialize_map(Some(value.len()))?;
+    for (k, v) in value {
+        map.serialize_entry(&snake_to_camel(k), v)?;
+    }
+    map.end()
+}
+
+/// Convert a string from snake case to camel case.
+fn snake_to_camel(input: &str) -> String {
+    match input.find('_') {
+        None => input.to_string(),
+        Some(first) => {
+            let mut result = String::with_capacity(input.len());
+            if first > 0 {
+                result.push_str(&input[..first]);
+            }
+            let mut capitalize = true;
+            for c in input[first + 1..].chars() {
+                if c == '_' {
+                    capitalize = true;
+                } else if capitalize {
+                    result.push(c.to_ascii_uppercase());
+                    capitalize = false;
+                } else {
+                    result.push(c.to_ascii_lowercase());
+                }
+            }
+            result
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn snake_to_camel_works() {
+        assert_eq!(snake_to_camel("this_is_a_test"), "thisIsATest");
+        assert_eq!(snake_to_camel("this___IS_a_TEST"), "thisIsATest");
+        assert_eq!(snake_to_camel("éàç_this_is_a_test"), "éàçThisIsATest");
+    }
+}