@temporalio/core-bridge 1.1.0 → 1.3.1

package/sdk-core/tests/integ_tests/workflow_tests/signals.rs

@@ -1,9 +1,11 @@
+use std::collections::HashMap;
+
 use futures::StreamExt;
 use temporal_client::{WorkflowClientTrait, WorkflowExecutionInfo, WorkflowOptions};
 use temporal_sdk::{
     ChildWorkflowOptions, Signal, SignalWorkflowOptions, WfContext, WorkflowResult,
 };
-use temporal_sdk_core_protos::coresdk::IntoPayloadsExt;
+use temporal_sdk_core_protos::{coresdk::IntoPayloadsExt, temporal::api::common::v1::Payload};
 use temporal_sdk_core_test_utils::CoreWfStarter;
 use uuid::Uuid;
 
@@ -57,7 +59,12 @@ async fn signal_receiver(ctx: WfContext) -> WorkflowResult<()> {
 
 async fn signal_with_create_wf_receiver(ctx: WfContext) -> WorkflowResult<()> {
     let res = ctx.make_signal_channel(SIGNAME).next().await.unwrap();
+    println!("HEADER: {:?}", res.headers);
     assert_eq!(&res.input, &[b"tada".into()]);
+    assert_eq!(
+        *res.headers.get("tupac").expect("tupac header exists"),
+        b"shakur".into()
+    );
     Ok(().into())
 }
 
@@ -96,15 +103,19 @@ async fn sends_signal_with_create_wf() {
     worker.register_wf("receiversignal", signal_with_create_wf_receiver);
 
     let client = starter.get_client().await;
+    let mut header: HashMap<String, Payload> = HashMap::new();
+    header.insert("tupac".into(), "shakur".into());
     let res = client
         .signal_with_start_workflow_execution(
             None,
             worker.inner_mut().task_queue().to_owned(),
             "sends_signal_with_create_wf".to_owned(),
             "receiversignal".to_owned(),
+            None,
             WorkflowOptions::default(),
             SIGNAME.to_owned(),
             vec![b"tada".into()].into_payloads(),
+            Some(header.into()),
         )
         .await
         .expect("request succeeds.qed");

package/sdk-core/tests/integ_tests/workflow_tests/timers.rs

@@ -42,7 +42,7 @@ async fn timer_workflow_manual() {
         task.run_id,
         vec![StartTimer {
             seq: 0,
-            start_to_fire_timeout: Some(Duration::from_secs(1).into()),
+            start_to_fire_timeout: Some(prost_dur!(from_secs(1))),
         }
         .into()],
     ))
@@ -63,12 +63,12 @@ async fn timer_cancel_workflow() {
         vec![
             StartTimer {
                 seq: 0,
-                start_to_fire_timeout: Some(Duration::from_millis(50).into()),
+                start_to_fire_timeout: Some(prost_dur!(from_millis(50))),
             }
             .into(),
             StartTimer {
                 seq: 1,
-                start_to_fire_timeout: Some(Duration::from_secs(10).into()),
+                start_to_fire_timeout: Some(prost_dur!(from_secs(10))),
             }
             .into(),
         ],

package/sdk-core/tests/integ_tests/workflow_tests.rs

@@ -223,7 +223,7 @@ async fn fail_wf_task(#[values(true, false)] replay: bool) {
         task.run_id,
         vec![StartTimer {
             seq: 0,
-            start_to_fire_timeout: Some(Duration::from_millis(200).into()),
+            start_to_fire_timeout: Some(prost_dur!(from_millis(200))),
         }
         .into()],
     ))
@@ -279,6 +279,7 @@ async fn signal_workflow() {
             res.run_id.to_string(),
             signal_id_1.to_string(),
             None,
+            None,
         )
         .await
         .unwrap();
@@ -288,6 +289,7 @@ async fn signal_workflow() {
             res.run_id.to_string(),
             signal_id_2.to_string(),
             None,
+            None,
         )
         .await
         .unwrap();
@@ -345,7 +347,7 @@ async fn signal_workflow_signal_not_handled_on_workflow_completion() {
             res.run_id,
             vec![StartTimer {
                 seq: 0,
-                start_to_fire_timeout: Some(Duration::from_millis(10).into()),
+                start_to_fire_timeout: Some(prost_dur!(from_millis(10))),
             }
             .into()],
         ))
@@ -374,6 +376,7 @@ async fn signal_workflow_signal_not_handled_on_workflow_completion() {
                     res.run_id.to_string(),
                     signal_id_1.to_string(),
                     None,
+                    None,
                 )
                 .await
                 .unwrap();
@@ -458,7 +461,13 @@ async fn wft_timeout_doesnt_create_unsolvable_autocomplete() {
     // Send the signals to the server & resolve activity -- sometimes this happens too fast
     sleep(Duration::from_millis(200)).await;
     client
-        .signal_workflow_execution(wf_id.to_string(), rid, signal_at_start.to_string(), None)
+        .signal_workflow_execution(
+            wf_id.to_string(),
+            rid,
+            signal_at_start.to_string(),
+            None,
+            None,
+        )
         .await
         .unwrap();
     // Complete activity successfully.
@@ -470,7 +479,13 @@ async fn wft_timeout_doesnt_create_unsolvable_autocomplete() {
     .unwrap();
     let rid = wf_task.run_id.clone();
     client
-        .signal_workflow_execution(wf_id.to_string(), rid, signal_at_complete.to_string(), None)
+        .signal_workflow_execution(
+            wf_id.to_string(),
+            rid,
+            signal_at_complete.to_string(),
+            None,
+            None,
+        )
         .await
         .unwrap();
     // Now poll again, it will be an eviction b/c non-sticky mode.

package/sdk-core/tests/load_tests.rs

@@ -35,13 +35,13 @@ async fn activity_load() {
             let activity = ActivityOptions {
                 activity_id: Some(activity_id.to_string()),
                 activity_type: "test_activity".to_string(),
-                input: Default::default(),
                 task_queue,
                 schedule_to_start_timeout: Some(activity_timeout),
                 start_to_close_timeout: Some(activity_timeout),
                 schedule_to_close_timeout: Some(activity_timeout),
                 heartbeat_timeout: Some(activity_timeout),
                 cancellation_type: ActivityCancellationType::TryCancel,
+                ..Default::default()
             };
             let res = ctx.activity(activity).await.unwrap_ok_payload();
             assert_eq!(res.data, payload_dat);
@@ -175,6 +175,7 @@ async fn workflow_load() {
                         "".to_string(),
                         SIGNAME.to_string(),
                         None,
+                        None,
                     )
                 })
                 .collect();

package/sdk-core/tests/main.rs

@@ -2,10 +2,20 @@
 
 #[cfg(test)]
 mod integ_tests {
+    #[macro_export]
+    macro_rules! prost_dur {
+        ($dur_call:ident $args:tt) => {
+            std::time::Duration::$dur_call$args
+                .try_into()
+                .expect("test duration fits")
+        };
+    }
     mod client_tests;
+    mod ephemeral_server_tests;
     mod heartbeat_tests;
     mod polling_tests;
     mod queries_tests;
+    mod visibility_tests;
     mod workflow_tests;
 
     use std::str::FromStr;

package/src/conversions.rs

@@ -1,5 +1,5 @@
+use crate::helpers::*;
 use log::LevelFilter;
-use neon::types::buffer::TypedArray;
 use neon::{
     context::Context,
     handle::Handle,
@@ -7,107 +7,50 @@ use neon::{
     types::{JsBoolean, JsNumber, JsString},
 };
 use opentelemetry::trace::{SpanContext, SpanId, TraceFlags, TraceId, TraceState};
-use std::{collections::HashMap, fmt::Display, net::SocketAddr, str::FromStr, time::Duration};
+use std::{collections::HashMap, net::SocketAddr, str::FromStr, time::Duration};
 use temporal_sdk_core::{
     api::worker::{WorkerConfig, WorkerConfigBuilder},
+    ephemeral_server::{
+        TemporaliteConfig, TemporaliteConfigBuilder, TestServerConfig, TestServerConfigBuilder,
+    },
     ClientOptions, ClientOptionsBuilder, ClientTlsConfig, Logger, MetricsExporter,
     OtelCollectorOptions, RetryConfig, TelemetryOptions, TelemetryOptionsBuilder, TlsConfig,
     TraceExporter, Url,
 };
 
-#[macro_export]
-macro_rules! js_optional_getter {
-    ($js_cx:expr, $js_obj:expr, $prop_name:expr, $js_type:ty) => {
-        match get_optional($js_cx, $js_obj, $prop_name) {
-            None => None,
-            Some(val) => {
-                if val.is_a::<$js_type, _>($js_cx) {
-                    Some(val.downcast_or_throw::<$js_type, _>($js_cx)?)
-                } else {
-                    Some($js_cx.throw_type_error(format!("Invalid {}", $prop_name))?)
-                }
-            }
-        }
-    };
+pub enum EphemeralServerConfig {
+    TestServer(TestServerConfig),
+    Temporalite(TemporaliteConfig),
 }
 
-macro_rules! js_value_getter {
-    ($js_cx:expr, $js_obj:expr, $prop_name:expr, $js_type:ty) => {
-        match js_optional_getter!($js_cx, $js_obj, $prop_name, $js_type) {
-            Some(val) => val.value($js_cx),
-            None => $js_cx.throw_type_error(format!("{} must be defined", $prop_name))?,
-        }
-    };
+pub trait ArrayHandleConversionsExt {
+    fn to_vec_of_string(&self, cx: &mut FunctionContext) -> NeonResult<Vec<String>>;
 }
 
-/// Helper for extracting an optional attribute from [obj].
-/// If [obj].[attr] is undefined or not present, None is returned
-pub fn get_optional<'a, C, K>(
-    cx: &mut C,
-    obj: &Handle<JsObject>,
-    attr: K,
-) -> Option<Handle<'a, JsValue>>
-where
-    K: neon::object::PropertyKey,
-    C: Context<'a>,
-{
-    match obj.get_value(cx, attr) {
-        Err(_) => None,
-        Ok(val) => match val.is_a::<JsUndefined, _>(cx) {
-            true => None,
-            false => Some(val),
-        },
-    }
-}
+impl ArrayHandleConversionsExt for Handle<'_, JsArray> {
+    fn to_vec_of_string(&self, cx: &mut FunctionContext) -> NeonResult<Vec<String>> {
+        let js_vec = self.to_vec(cx)?;
+        let len = js_vec.len();
+        let mut ret_vec = Vec::<String>::with_capacity(len);
 
-/// Helper for extracting a Vec<u8> from optional Buffer at [obj].[attr]
-fn get_optional_vec<'a, C, K>(
-    cx: &mut C,
-    obj: &Handle<JsObject>,
-    attr: K,
-) -> Result<Option<Vec<u8>>, neon::result::Throw>
-where
-    K: neon::object::PropertyKey + Display + Clone,
-    C: Context<'a>,
-{
-    if let Some(val) = get_optional(cx, obj, attr.clone()) {
-        let buf = val.downcast::<JsBuffer, C>(cx).map_err(|_| {
-            cx.throw_type_error::<_, Option<Vec<u8>>>(format!("Invalid {}", attr))
-                .unwrap_err()
-        })?;
-        Ok(Some(buf.as_slice(cx).to_vec()))
-    } else {
-        Ok(None)
-    }
-}
-
-/// Helper for extracting a Vec<u8> from optional Buffer at [obj].[attr]
-fn get_vec<'a, C, K>(
-    cx: &mut C,
-    obj: &Handle<JsObject>,
-    attr: K,
-    full_attr_path: &str,
-) -> Result<Vec<u8>, neon::result::Throw>
-where
-    K: neon::object::PropertyKey + Display + Clone,
-    C: Context<'a>,
-{
-    if let Some(val) = get_optional(cx, obj, attr.clone()) {
-        let buf = val.downcast::<JsBuffer, C>(cx).map_err(|_| {
-            cx.throw_type_error::<_, Option<Vec<u8>>>(format!("Invalid {}", attr))
-                .unwrap_err()
-        })?;
-        Ok(buf.as_slice(cx).to_vec())
-    } else {
-        cx.throw_type_error::<_, Vec<u8>>(format!("Invalid or missing {}", full_attr_path))
+        for i in 0..len - 1 {
+            ret_vec[i] = js_vec[i].downcast_or_throw::<JsString, _>(cx)?.value(cx);
+        }
+        Ok(ret_vec)
     }
 }
 
-pub(crate) trait ObjectHandleConversionsExt {
+pub trait ObjectHandleConversionsExt {
+    fn set_default(&self, cx: &mut FunctionContext, key: &str, value: &str) -> NeonResult<()>;
     fn as_otel_span_context(&self, ctx: &mut FunctionContext) -> NeonResult<SpanContext>;
     fn as_client_options(&self, ctx: &mut FunctionContext) -> NeonResult<ClientOptions>;
     fn as_telemetry_options(&self, cx: &mut FunctionContext) -> NeonResult<TelemetryOptions>;
     fn as_worker_config(&self, cx: &mut FunctionContext) -> NeonResult<WorkerConfig>;
+    fn as_ephemeral_server_config(
+        &self,
+        cx: &mut FunctionContext,
+        sdk_version: String,
+    ) -> NeonResult<EphemeralServerConfig>;
     fn as_hash_map_of_string_to_string(
         &self,
         cx: &mut FunctionContext,
@@ -154,8 +97,7 @@ impl ObjectHandleConversionsExt for Handle<'_, JsObject> {
         let tls_cfg = match js_optional_getter!(cx, self, "tls", JsObject) {
             None => None,
             Some(tls) => {
-                let domain = js_optional_getter!(cx, &tls, "serverNameOverride", JsString)
-                    .map(|h| h.value(cx));
+                let domain = js_optional_value_getter!(cx, &tls, "serverNameOverride", JsString);
 
                 let server_root_ca_cert = get_optional_vec(cx, &tls, "serverRootCACertificate")?;
                 let client_tls_config =
@@ -207,13 +149,13 @@ impl ObjectHandleConversionsExt for Handle<'_, JsObject> {
                     "maxInterval",
                     JsNumber
                 ) as u64),
-                max_elapsed_time: js_optional_getter!(
+                max_elapsed_time: js_optional_value_getter!(
                     cx,
                     &retry_config,
                     "maxElapsedTime",
                     JsNumber
                 )
-                .map(|val| Duration::from_millis(val.value(cx) as u64)),
+                .map(|val| Duration::from_millis(val as u64)),
                 max_retries: js_value_getter!(cx, retry_config, "maxRetries", JsNumber) as usize,
             },
         };
@@ -235,12 +177,11 @@ impl ObjectHandleConversionsExt for Handle<'_, JsObject> {
     fn as_telemetry_options(&self, cx: &mut FunctionContext) -> NeonResult<TelemetryOptions> {
         let mut telemetry_opts = TelemetryOptionsBuilder::default();
 
-        if let Some(tf) = js_optional_getter!(cx, self, "tracingFilter", JsString) {
-            telemetry_opts.tracing_filter(tf.value(cx));
+        if let Some(tf) = js_optional_value_getter!(cx, self, "tracingFilter", JsString) {
+            telemetry_opts.tracing_filter(tf);
         }
         telemetry_opts.no_temporal_prefix_for_metrics(
-            js_optional_getter!(cx, self, "noTemporalPrefixForMetrics", JsBoolean)
-                .map(|b| b.value(cx))
+            js_optional_value_getter!(cx, self, "noTemporalPrefixForMetrics", JsBoolean)
                 .unwrap_or_default(),
         );
         if let Some(ref logging) = js_optional_getter!(cx, self, "logging", JsObject) {
@@ -382,4 +323,110 @@ impl ObjectHandleConversionsExt for Handle<'_, JsObject> {
             Err(e) => cx.throw_error(format!("Invalid worker config: {:?}", e)),
         }
     }
+
+    fn set_default(&self, cx: &mut FunctionContext, key: &str, value: &str) -> NeonResult<()> {
+        let key = cx.string(key);
+        let existing: Option<Handle<JsString>> = self.get_opt(cx, key)?;
+        if existing.is_none() {
+            let value = cx.string(value);
+            self.set(cx, key, value)?;
+        }
+        Ok(())
+    }
+
+    fn as_ephemeral_server_config(
+        &self,
+        cx: &mut FunctionContext,
+        sdk_version: String,
+    ) -> NeonResult<EphemeralServerConfig> {
+        let js_executable = js_optional_getter!(cx, self, "executable", JsObject)
+            .unwrap_or_else(|| cx.empty_object());
+        js_executable.set_default(cx, "type", "cached-download")?;
+
+        let exec_type = js_value_getter!(cx, &js_executable, "type", JsString);
+        let executable = match exec_type.as_str() {
+            "cached-download" => {
+                let version = js_optional_value_getter!(cx, &js_executable, "version", JsString)
+                    .unwrap_or("default".to_owned());
+                let dest_dir =
+                    js_optional_value_getter!(cx, &js_executable, "downloadDir", JsString);
+
+                let exec_version = match version.as_str() {
+                    "default" => {
+                        temporal_sdk_core::ephemeral_server::EphemeralExeVersion::Default {
+                            sdk_name: "sdk-typescript".to_owned(),
+                            sdk_version,
+                        }
+                    }
+                    _ => temporal_sdk_core::ephemeral_server::EphemeralExeVersion::Fixed(version),
+                };
+                temporal_sdk_core::ephemeral_server::EphemeralExe::CachedDownload {
+                    version: exec_version,
+                    dest_dir,
+                }
+            }
+            "existing-path" => {
+                let path = js_value_getter!(cx, &js_executable, "path", JsString);
+                temporal_sdk_core::ephemeral_server::EphemeralExe::ExistingPath(path)
+            }
+            _ => {
+                return cx.throw_type_error(format!("Invalid executable type: {}", exec_type))?;
+            }
+        };
+        let port = js_optional_getter!(cx, self, "port", JsNumber).map(|s| s.value(cx) as u16);
+
+        let server_type = js_value_getter!(cx, self, "type", JsString);
+        match server_type.as_str() {
+            "temporalite" => {
+                let mut config = TemporaliteConfigBuilder::default();
+                config.exe(executable).port(port);
+
+                if let Some(extra_args) = js_optional_getter!(cx, self, "extraArgs", JsArray) {
+                    config.extra_args(extra_args.to_vec_of_string(cx)?);
+                };
+                if let Some(namespace) = js_optional_value_getter!(cx, self, "namespace", JsString)
+                {
+                    config.namespace(namespace);
+                }
+                if let Some(ip) = js_optional_value_getter!(cx, self, "ip", JsString) {
+                    config.ip(ip);
+                }
+                config.db_filename(js_optional_value_getter!(cx, self, "dbFilename", JsString));
+                config.ui(js_optional_value_getter!(cx, self, "ui", JsBoolean).unwrap_or_default());
+
+                if let Some(log) = js_optional_getter!(cx, self, "log", JsObject) {
+                    let format = js_value_getter!(cx, &log, "format", JsString);
+                    let level = js_value_getter!(cx, &log, "level", JsString);
+                    config.log((format, level));
+                }
+
+                match config.build() {
+                    Ok(config) => Ok(EphemeralServerConfig::Temporalite(config)),
+                    Err(err) => {
+                        cx.throw_type_error(format!("Invalid temporalite config: {:?}", err))
+                    }
+                }
+            }
+            "time-skipping" => {
+                let mut config = TestServerConfigBuilder::default();
+                config.exe(executable).port(port);
+
+                if let Some(extra_args_js) = js_optional_getter!(cx, self, "extraArgs", JsArray) {
+                    let extra_args = extra_args_js.to_vec_of_string(cx)?;
+                    config.extra_args(extra_args);
+                };
+
+                match config.build() {
+                    Ok(config) => Ok(EphemeralServerConfig::TestServer(config)),
+                    Err(err) => {
+                        cx.throw_type_error(format!("Invalid test server config: {:?}", err))
+                    }
+                }
+            }
+            s => cx.throw_type_error(format!(
+                "Invalid ephemeral server type: {}, expected 'temporalite' or 'time-skipping'",
+                s
+            )),
+        }
+    }
 }

package/src/helpers.rs

@@ -0,0 +1,190 @@
+use crate::errors::*;
+use neon::prelude::*;
+use neon::types::buffer::TypedArray;
+use std::{fmt::Display, future::Future, sync::Arc};
+
+/// Send a result to JS via callback using a [Channel]
+pub fn send_result<F, T>(channel: Arc<Channel>, callback: Root<JsFunction>, res_fn: F)
+where
+    F: for<'a> FnOnce(&mut TaskContext<'a>) -> NeonResult<Handle<'a, T>> + Send + 'static,
+    T: Value,
+{
+    channel.send(move |mut cx| {
+        let callback = callback.into_inner(&mut cx);
+        let this = cx.undefined();
+        let error = cx.undefined();
+        let result = res_fn(&mut cx)?;
+        let args: Vec<Handle<JsValue>> = vec![error.upcast(), result.upcast()];
+        callback.call(&mut cx, this, args)?;
+        Ok(())
+    });
+}
+
+/// Send an error to JS via callback using a [Channel]
+pub fn send_error<E, F>(channel: Arc<Channel>, callback: Root<JsFunction>, error_ctor: F)
+where
+    E: Object,
+    F: for<'a> FnOnce(&mut TaskContext<'a>) -> JsResult<'a, E> + Send + 'static,
+{
+    channel.send(move |mut cx| {
+        let callback = callback.into_inner(&mut cx);
+        callback_with_error(&mut cx, callback, error_ctor)
+    });
+}
+
+/// Call `callback` with given error
+pub fn callback_with_error<'a, C, E, F>(
+    cx: &mut C,
+    callback: Handle<JsFunction>,
+    error_ctor: F,
+) -> NeonResult<()>
+where
+    C: Context<'a>,
+    E: Object,
+    F: FnOnce(&mut C) -> JsResult<'a, E> + Send + 'static,
+{
+    let this = cx.undefined();
+    let error = error_ctor(cx)?;
+    let result = cx.undefined();
+    let args: Vec<Handle<JsValue>> = vec![error.upcast(), result.upcast()];
+    callback.call(cx, this, args)?;
+    Ok(())
+}
+
+/// Call `callback` with an UnexpectedError created from `err`
+pub fn callback_with_unexpected_error<'a, C, E>(
+    cx: &mut C,
+    callback: Handle<JsFunction>,
+    err: E,
+) -> NeonResult<()>
+where
+    C: Context<'a>,
+    E: std::fmt::Display,
+{
+    let err_str = format!("{}", err);
+    callback_with_error(cx, callback, move |cx| {
+        UNEXPECTED_ERROR.from_string(cx, err_str)
+    })
+}
+
+/// When Future completes, call given JS callback using a neon::Channel with either error or
+/// undefined
+pub async fn void_future_to_js<E, F, ER, EF>(
+    channel: Arc<Channel>,
+    callback: Root<JsFunction>,
+    f: F,
+    error_function: EF,
+) where
+    E: Display + Send + 'static,
+    F: Future<Output = Result<(), E>> + Send,
+    ER: Object,
+    EF: for<'a> FnOnce(&mut TaskContext<'a>, E) -> JsResult<'a, ER> + Send + 'static,
+{
+    match f.await {
+        Ok(()) => {
+            send_result(channel, callback, |cx| Ok(cx.undefined()));
+        }
+        Err(err) => {
+            send_error(channel, callback, |cx| error_function(cx, err));
+        }
+    }
+}
+
+macro_rules! js_optional_getter {
+    ($js_cx:expr, $js_obj:expr, $prop_name:expr, $js_type:ty) => {
+        match get_optional($js_cx, $js_obj, $prop_name) {
+            None => None,
+            Some(val) => {
+                if val.is_a::<$js_type, _>($js_cx) {
+                    Some(val.downcast_or_throw::<$js_type, _>($js_cx)?)
+                } else {
+                    Some($js_cx.throw_type_error(format!("Invalid {}", $prop_name))?)
+                }
+            }
+        }
+    };
+}
+
+pub(crate) use js_optional_getter;
+
+macro_rules! js_optional_value_getter {
+    ($js_cx:expr, $js_obj:expr, $prop_name:expr, $js_type:ty) => {
+        js_optional_getter!($js_cx, $js_obj, $prop_name, $js_type).map(|v| v.value($js_cx))
+    };
+}
+
+pub(crate) use js_optional_value_getter;
+
+macro_rules! js_value_getter {
+    ($js_cx:expr, $js_obj:expr, $prop_name:expr, $js_type:ty) => {
+        match js_optional_getter!($js_cx, $js_obj, $prop_name, $js_type) {
+            Some(val) => val.value($js_cx),
+            None => $js_cx.throw_type_error(format!("{} must be defined", $prop_name))?,
+        }
+    };
+}
+
+pub(crate) use js_value_getter;
+
+/// Helper for extracting an optional attribute from [obj].
+/// If [obj].[attr] is undefined or not present, None is returned
+pub fn get_optional<'a, C, K>(
+    cx: &mut C,
+    obj: &Handle<JsObject>,
+    attr: K,
+) -> Option<Handle<'a, JsValue>>
+where
+    K: neon::object::PropertyKey,
+    C: Context<'a>,
+{
+    match obj.get_value(cx, attr) {
+        Err(_) => None,
+        Ok(val) => match val.is_a::<JsUndefined, _>(cx) {
+            true => None,
+            false => Some(val),
+        },
+    }
+}
+
+/// Helper for extracting a Vec<u8> from optional Buffer at [obj].[attr]
+pub fn get_optional_vec<'a, C, K>(
+    cx: &mut C,
+    obj: &Handle<JsObject>,
+    attr: K,
+) -> Result<Option<Vec<u8>>, neon::result::Throw>
+where
+    K: neon::object::PropertyKey + Display + Clone,
+    C: Context<'a>,
+{
+    if let Some(val) = get_optional(cx, obj, attr.clone()) {
+        let buf = val.downcast::<JsBuffer, C>(cx).map_err(|_| {
+            cx.throw_type_error::<_, Option<Vec<u8>>>(format!("Invalid {}", attr))
+                .unwrap_err()
+        })?;
+        Ok(Some(buf.as_slice(cx).to_vec()))
+    } else {
+        Ok(None)
+    }
+}
+
+/// Helper for extracting a Vec<u8> from optional Buffer at [obj].[attr]
+pub fn get_vec<'a, C, K>(
+    cx: &mut C,
+    obj: &Handle<JsObject>,
+    attr: K,
+    full_attr_path: &str,
+) -> Result<Vec<u8>, neon::result::Throw>
+where
+    K: neon::object::PropertyKey + Display + Clone,
+    C: Context<'a>,
+{
+    if let Some(val) = get_optional(cx, obj, attr.clone()) {
+        let buf = val.downcast::<JsBuffer, C>(cx).map_err(|_| {
+            cx.throw_type_error::<_, Option<Vec<u8>>>(format!("Invalid {}", attr))
+                .unwrap_err()
+        })?;
+        Ok(buf.as_slice(cx).to_vec())
+    } else {
+        cx.throw_type_error::<_, Vec<u8>>(format!("Invalid or missing {}", full_attr_path))
+    }
+}