@temporalio/core-bridge 0.14.0 → 0.16.4

package/src/conversions.rs

@@ -276,6 +276,21 @@ impl ObjectHandleConversionsExt for Handle<'_, JsObject> {
         ) as u64);
         let max_cached_workflows =
             js_value_getter!(cx, self, "maxCachedWorkflows", JsNumber) as usize;
+
+        let max_heartbeat_throttle_interval = Duration::from_millis(js_value_getter!(
+            cx,
+            self,
+            "maxHeartbeatThrottleIntervalMs",
+            JsNumber
+        ) as u64);
+
+        let default_heartbeat_throttle_interval = Duration::from_millis(js_value_getter!(
+            cx,
+            self,
+            "defaultHeartbeatThrottleIntervalMs",
+            JsNumber
+        ) as u64);
+
         Ok(WorkerConfig {
             no_remote_activities: false, // TODO: make this configurable once Core implements local activities
             max_concurrent_at_polls,
@@ -286,6 +301,8 @@ impl ObjectHandleConversionsExt for Handle<'_, JsObject> {
             nonsticky_to_sticky_poll_ratio,
             sticky_queue_schedule_to_start_timeout,
             task_queue,
+            max_heartbeat_throttle_interval,
+            default_heartbeat_throttle_interval,
         })
     }
 }

package/src/errors.rs

@@ -8,8 +8,6 @@ pub static TRANSPORT_ERROR: OnceCell<Root<JsFunction>> = OnceCell::new();
 pub static SHUTDOWN_ERROR: OnceCell<Root<JsFunction>> = OnceCell::new();
 /// Thrown when using a method for a worker that does not exist (never registered or already shut down)
 pub static NO_WORKER_ERROR: OnceCell<Root<JsFunction>> = OnceCell::new();
-/// Workflow did something Core did not expect, it should be immediately deleted from the cache
-pub static WORKFLOW_ERROR: OnceCell<Root<JsFunction>> = OnceCell::new();
 /// Something unexpected happened, considered fatal
 pub static UNEXPECTED_ERROR: OnceCell<Root<JsFunction>> = OnceCell::new();
 
@@ -80,10 +78,6 @@ pub fn register_errors(mut cx: FunctionContext) -> JsResult<JsUndefined> {
         .get(&mut cx, "TransportError")?
         .downcast_or_throw::<JsFunction, FunctionContext>(&mut cx)?
         .root(&mut cx);
-    let workflow_error = mapping
-        .get(&mut cx, "WorkflowError")?
-        .downcast_or_throw::<JsFunction, FunctionContext>(&mut cx)?
-        .root(&mut cx);
     let unexpected_error = mapping
         .get(&mut cx, "UnexpectedError")?
         .downcast_or_throw::<JsFunction, FunctionContext>(&mut cx)?
@@ -92,7 +86,6 @@ pub fn register_errors(mut cx: FunctionContext) -> JsResult<JsUndefined> {
     TRANSPORT_ERROR.get_or_try_init(|| Ok(transport_error))?;
     SHUTDOWN_ERROR.get_or_try_init(|| Ok(shutdown_error))?;
     NO_WORKER_ERROR.get_or_try_init(|| Ok(no_worker_error))?;
-    WORKFLOW_ERROR.get_or_try_init(|| Ok(workflow_error))?;
     UNEXPECTED_ERROR.get_or_try_init(|| Ok(unexpected_error))?;
 
     Ok(cx.undefined())

package/src/lib.rs

@@ -353,14 +353,6 @@ fn start_bridge_loop(
                                             .await
                                     },
                                     |cx, err| match err {
-                                        CompleteWfError::WorkflowUpdateError { run_id, source } => {
-                                            let args = vec![
-                                                cx.string("Workflow update error").upcast(),
-                                                cx.string(run_id).upcast(),
-                                                cx.string(format!("{}", source)).upcast(),
-                                            ];
-                                            WORKFLOW_ERROR.construct(cx, args)
-                                        }
                                         CompleteWfError::NoWorkerForQueue(queue_name) => {
                                             let args = vec![cx.string(queue_name).upcast()];
                                             NO_WORKER_ERROR.construct(cx, args)
@@ -445,18 +437,6 @@ async fn handle_poll_workflow_activation_request(
         Err(err) => {
             send_error(event_queue, callback, move |cx| match err {
                 PollWfError::ShutDown => SHUTDOWN_ERROR.from_error(cx, err),
-                PollWfError::AutocompleteError(CompleteWfError::WorkflowUpdateError {
-                    run_id,
-                    source,
-                })
-                | PollWfError::WorkflowUpdateError { run_id, source } => {
-                    let args = vec![
-                        cx.string("Workflow update error").upcast(),
-                        cx.string(run_id).upcast(),
-                        cx.string(format!("{}", source)).upcast(),
-                    ];
-                    WORKFLOW_ERROR.construct(cx, args)
-                }
                 PollWfError::AutocompleteError(CompleteWfError::NoWorkerForQueue(_)) => {
                     UNEXPECTED_ERROR
                         .from_error(cx, format!("No worker registered for queue {}", queue_name))