@temporalio/core-bridge 1.11.8 → 1.12.0

package/src/helpers.rs

@@ -1,297 +0,0 @@
-use crate::errors::*;
-use neon::{prelude::*, 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: Display,
-{
-    let err_str = format!("{}", err);
-    callback_with_error(cx, callback, move |cx| {
-        make_named_error_from_string(cx, UNEXPECTED_ERROR, 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_getter {
-    ($js_cx:expr, $js_obj:expr, $prop_name:expr, $js_type:ty) => {
-        match get_optional($js_cx, $js_obj, $prop_name) {
-            None => $js_cx.throw_type_error(format!("{} must be defined", $prop_name))?,
-            Some(val) => {
-                if val.is_a::<$js_type, _>($js_cx) {
-                    val.downcast_or_throw::<$js_type, _>($js_cx)?
-                } else {
-                    $js_cx.throw_type_error(format!("Invalid {}", $prop_name))?
-                }
-            }
-        }
-    };
-}
-
-pub(crate) use js_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))
-    }
-}
-
-// Recursively convert a Serde value to a JS value
-pub fn serde_value_to_js_value<'a>(
-    cx: &mut impl Context<'a>,
-    val: serde_json::Value,
-) -> JsResult<'a, JsValue> {
-    match val {
-        serde_json::Value::String(s) => Ok(cx.string(s).upcast()),
-        serde_json::Value::Number(n) => Ok(cx.number(n.as_f64().unwrap()).upcast()),
-        serde_json::Value::Bool(b) => Ok(cx.boolean(b).upcast()),
-        serde_json::Value::Null => Ok(cx.null().upcast()),
-        serde_json::Value::Array(vec) => {
-            let arr: Handle<'a, JsArray> = JsArray::new(cx, vec.len());
-            for (i, v) in vec.into_iter().enumerate() {
-                let v = serde_value_to_js_value(cx, v)?;
-                arr.set(cx, i as u32, v)?;
-            }
-            Ok(arr.upcast())
-        }
-        serde_json::Value::Object(map) => hashmap_to_js_value(cx, map).map(|v| v.upcast()),
-    }
-}
-
-pub fn hashmap_to_js_value<'a>(
-    cx: &mut impl Context<'a>,
-    map: impl IntoIterator<Item = (String, serde_json::Value)>,
-) -> JsResult<'a, JsObject> {
-    let obj: Handle<'a, JsObject> = cx.empty_object();
-    for (k, v) in map {
-        let k = cx.string(snake_to_camel(k));
-        let v = serde_value_to_js_value(cx, v)?;
-        obj.set(cx, k, v)?;
-    }
-    Ok(obj)
-}
-
-fn snake_to_camel(input: String) -> String {
-    match input.find('_') {
-        None => input,
-        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
-        }
-    }
-}
-
-#[allow(dead_code)]
-// Useful to help debug JSObject contents
-pub fn log_js_object<'a, 'b, C: Context<'b>>(cx: &mut C, js_object: &Handle<'a, JsObject>) {
-    let global = cx.global_object();
-    let console = global
-        .get::<JsObject, _, _>(cx, "console")
-        .expect("Failed to get console object");
-
-    let log = console
-        .get::<JsFunction, _, _>(cx, "log")
-        .expect("Failed to get log function");
-
-    let args = vec![js_object.upcast()]; // Upcast js_object to JsValue
-    log.call(cx, console, args)
-        .expect("Failed to call console.log");
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn snake_to_camel_works() {
-        assert_eq!(snake_to_camel("this_is_a_test".into()), "thisIsATest");
-        assert_eq!(snake_to_camel("this___IS_a_TEST".into()), "thisIsATest");
-        assert_eq!(
-            snake_to_camel("éàç_this_is_a_test".into()),
-            "éàçThisIsATest"
-        );
-    }
-}

package/ts/worker-tuner.ts

@@ -1,193 +0,0 @@
-/**
- * A worker tuner allows the customization of the performance characteristics of workers by
- * controlling how "slots" are handed out for different task types. In order to poll for and then
- * run tasks, a slot must first be reserved by the {@link SlotSupplier} returned by the tuner.
- *
- * @experimental
- */
-export interface WorkerTuner {
-  workflowTaskSlotSupplier: SlotSupplier;
-  activityTaskSlotSupplier: SlotSupplier;
-  localActivityTaskSlotSupplier: SlotSupplier;
-}
-
-export type SlotInfo = WorkflowSlotInfo | ActivitySlotInfo | LocalActivitySlotInfo;
-
-export interface WorkflowSlotInfo {
-  type: 'workflow';
-  workflowId: string;
-  runId: string;
-}
-
-export interface ActivitySlotInfo {
-  type: 'activity';
-  activityId: string;
-}
-
-export interface LocalActivitySlotInfo {
-  type: 'local-activity';
-  activityId: string;
-}
-
-/**
- * Controls how slots are handed out for a specific task type.
- *
- * For now, only {@link ResourceBasedSlotOptions} and {@link FixedSizeSlotSupplier} are supported,
- * but we may add support for custom tuners in the future.
- *
- * @experimental
- */
-export type SlotSupplier = ResourceBasedSlotsForType | FixedSizeSlotSupplier | CustomSlotSupplier<any>;
-
-/**
- * Options for a specific slot type within a {@link ResourceBasedSlotsForType}
- *
- * @experimental
- */
-export interface ResourceBasedSlotOptions {
-  // Amount of slots that will be issued regardless of any other checks
-  minimumSlots: number;
-  // Maximum amount of slots permitted
-  maximumSlots: number;
-  // Minimum time we will wait (after passing the minimum slots number) between handing out new
-  // slots in milliseconds.
-  rampThrottleMs: number;
-}
-
-/**
- * @experimental
- */
-type ResourceBasedSlotsForType = ResourceBasedSlotOptions & {
-  type: 'resource-based';
-  tunerOptions: ResourceBasedTunerOptions;
-};
-
-/**
- * Options for a {@link ResourceBasedTuner} to control target resource usage
- *
- * @experimental
- */
-export interface ResourceBasedTunerOptions {
-  // A value between 0 and 1 that represents the target (system) memory usage. It's not recommended
-  // to set this higher than 0.8, since how much memory a workflow may use is not predictable, and
-  // you don't want to encounter OOM errors.
-  targetMemoryUsage: number;
-  // A value between 0 and 1 that represents the target (system) CPU usage. This can be set to 1.0
-  // if desired, but it's recommended to leave some headroom for other processes.
-  targetCpuUsage: number;
-}
-
-/**
- * A fixed-size slot supplier that will never issue more than a fixed number of slots.
- *
- * @experimental
- */
-export interface FixedSizeSlotSupplier {
-  type: 'fixed-size';
-  // The maximum number of slots that can be issued
-  numSlots: number;
-}
-
-/**
- * The interface can be implemented to provide custom slot supplier behavior.
- */
-export interface CustomSlotSupplier<SI extends SlotInfo> {
-  type: 'custom';
-
-  /**
-   * This function is called before polling for new tasks. Your implementation should block until a
-   * slot is available then return a permit to use that slot.
-   *
-   * The only acceptable exception to throw is AbortError, any other exceptions thrown will be
-   * logged and ignored.
-   *
-   * The value inside the returned promise should be an object, however other types will still count
-   * as having issued a permit. Including undefined or null. Returning undefined or null does *not*
-   * mean you have not issued a permit. Implementations are expected to block until a meaningful
-   * permit can be issued.
-   *
-   * @param ctx The context for slot reservation.
-   * @param abortSignal The SDK may decide to abort the reservation request if it's no longer
-   *   needed. Implementations may clean up and then must reject the promise with AbortError.
-   * @returns A permit to use the slot which may be populated with your own data.
-   */
-  reserveSlot(ctx: SlotReserveContext, abortSignal: AbortSignal): Promise<SlotPermit>;
-
-  /**
-   * This function is called when trying to reserve slots for "eager" workflow and activity tasks.
-   * Eager tasks are those which are returned as a result of completing a workflow task, rather than
-   * from polling. Your implementation must not block, and if a slot is available, return a permit
-   * to use that slot.
-   *
-   * @param ctx The context for slot reservation.
-   * @returns Maybe a permit to use the slot which may be populated with your own data.
-   */
-  tryReserveSlot(ctx: SlotReserveContext): SlotPermit | null;
-
-  /**
-   * This function is called once a slot is actually being used to process some task, which may be
-   * some time after the slot was reserved originally. For example, if there is no work for a
-   * worker, a number of slots equal to the number of active pollers may already be reserved, but
-   * none of them are being used yet. This call should be non-blocking.
-   *
-   * @param ctx The context for marking a slot as used.
-   */
-  markSlotUsed(slot: SlotMarkUsedContext<SI>): void;
-
-  /**
-   * This function is called once a permit is no longer needed. This could be because the task has
-   * finished, whether successfully or not, or because the slot was no longer needed (ex: the number
-   * of active pollers decreased). This call should be non-blocking.
-   *
-   * @param ctx The context for releasing a slot.
-   */
-  releaseSlot(slot: SlotReleaseContext<SI>): void;
-}
-
-export interface SlotPermit {}
-
-export interface SlotReserveContext {
-  /**
-   * The type of slot trying to be reserved
-   */
-  slotType: SlotInfo['type'];
-  /**
-   * The name of the task queue for which this reservation request is associated
-   */
-  taskQueue: string;
-  /**
-   * The identity of the worker that is requesting the reservation
-   */
-  workerIdentity: string;
-  /**
-   * The build id of the worker that is requesting the reservation
-   */
-  workerBuildId: string;
-  /**
-   * True iff this is a reservation for a sticky poll for a workflow task
-   */
-  isSticky: boolean;
-}
-
-export interface SlotMarkUsedContext<SI extends SlotInfo> {
-  /**
-   * Info about the task that will be using the slot
-   */
-  slotInfo: SI;
-  /**
-   * The permit that was issued when the slot was reserved
-   */
-  permit: SlotPermit;
-}
-
-export interface SlotReleaseContext<SI extends SlotInfo> {
-  /**
-   * Info about the task that used this slot, if any. A slot may be released without being used in
-   * the event a poll times out.
-   */
-  slotInfo?: SI;
-  /**
-   * The permit that was issued when the slot was reserved
-   */
-  permit: SlotPermit;
-}