@temporalio/core-bridge 1.12.2 → 1.13.0

package/sdk-core/tests/shared_tests/priority.rs

@@ -0,0 +1,155 @@
+use std::time::Duration;
+use temporal_client::{
+    GetWorkflowResultOpts, Priority, WfClientExt, WorkflowClientTrait, WorkflowOptions,
+};
+use temporal_sdk::{ActContext, ActivityOptions, ChildWorkflowOptions, WfContext};
+use temporal_sdk_core_protos::{
+    coresdk::AsJsonPayloadExt,
+    temporal::api::{common, history::v1::history_event::Attributes},
+};
+use temporal_sdk_core_test_utils::CoreWfStarter;
+
+pub(crate) async fn priority_values_sent_to_server() {
+    let mut starter = if let Some(wfs) =
+        CoreWfStarter::new_cloud_or_local("priority_values_sent_to_server", ">=1.29.0-139.2").await
+    {
+        wfs
+    } else {
+        return;
+    };
+    starter.workflow_options.priority = Some(Priority {
+        priority_key: 1,
+        fairness_key: "fair-wf".to_string(),
+        fairness_weight: 4.2,
+    });
+    let mut worker = starter.worker().await;
+    let child_type = "child-wf";
+
+    worker.register_wf(starter.get_task_queue(), move |ctx: WfContext| async move {
+        let child = ctx.child_workflow(ChildWorkflowOptions {
+            workflow_id: format!("{}-child", ctx.task_queue()),
+            workflow_type: child_type.to_owned(),
+            options: WorkflowOptions {
+                priority: Some(Priority {
+                    priority_key: 4,
+                    fairness_key: "fair-child".to_string(),
+                    fairness_weight: 1.23,
+                }),
+                ..Default::default()
+            },
+            ..Default::default()
+        });
+
+        let started = child
+            .start(&ctx)
+            .await
+            .into_started()
+            .expect("Child should start OK");
+        let activity = ctx.activity(ActivityOptions {
+            activity_type: "echo".to_owned(),
+            input: "hello".as_json_payload().unwrap(),
+            start_to_close_timeout: Some(Duration::from_secs(5)),
+            priority: Some(Priority {
+                priority_key: 5,
+                fairness_key: "fair-act".to_string(),
+                fairness_weight: 1.1,
+            }),
+            // Currently no priority info attached to eagerly run activities
+            do_not_eagerly_execute: true,
+            ..Default::default()
+        });
+        started.result().await;
+        activity.await.unwrap_ok_payload();
+        Ok(().into())
+    });
+    worker.register_wf(child_type.to_owned(), |ctx: WfContext| async move {
+        assert_eq!(
+            ctx.workflow_initial_info().priority,
+            Some(common::v1::Priority {
+                priority_key: 4,
+                fairness_key: "fair-child".to_string(),
+                fairness_weight: 1.23
+            })
+        );
+        Ok(().into())
+    });
+    worker.register_activity("echo", |ctx: ActContext, echo_me: String| async move {
+        assert_eq!(
+            ctx.get_info().priority,
+            Priority {
+                priority_key: 5,
+                fairness_key: "fair-act".to_string(),
+                fairness_weight: 1.1
+            }
+        );
+        Ok(echo_me)
+    });
+
+    starter
+        .start_with_worker(starter.get_task_queue(), &mut worker)
+        .await;
+    worker.run_until_done().await.unwrap();
+
+    let client = starter.get_client().await;
+    let handle = client.get_untyped_workflow_handle(starter.get_task_queue(), "");
+    let res = handle
+        .get_workflow_result(GetWorkflowResultOpts::default())
+        .await
+        .unwrap();
+    // Expect workflow success
+    res.unwrap_success();
+    let history = client
+        .get_workflow_execution_history(starter.get_task_queue().to_owned(), None, vec![])
+        .await
+        .unwrap()
+        .history
+        .unwrap();
+    let workflow_init_event = history
+        .events
+        .iter()
+        .find_map(|e| {
+            if let Attributes::WorkflowExecutionStartedEventAttributes(e) =
+                e.attributes.as_ref().unwrap()
+            {
+                Some(e)
+            } else {
+                None
+            }
+        })
+        .unwrap();
+    assert_eq!(
+        workflow_init_event.priority.as_ref().unwrap().priority_key,
+        1
+    );
+    let child_init_event = history
+        .events
+        .iter()
+        .find_map(|e| {
+            if let Attributes::StartChildWorkflowExecutionInitiatedEventAttributes(e) =
+                e.attributes.as_ref().unwrap()
+            {
+                Some(e)
+            } else {
+                None
+            }
+        })
+        .unwrap();
+    assert_eq!(child_init_event.priority.as_ref().unwrap().priority_key, 4);
+    let activity_sched_event = history
+        .events
+        .iter()
+        .find_map(|e| {
+            if let Attributes::ActivityTaskScheduledEventAttributes(e) =
+                e.attributes.as_ref().unwrap()
+            {
+                Some(e)
+            } else {
+                None
+            }
+        })
+        .unwrap();
+    assert_eq!(
+        activity_sched_event.priority.as_ref().unwrap().priority_key,
+        5
+    );
+}

package/src/client.rs

@@ -8,9 +8,7 @@ use tonic::metadata::MetadataKey;
 use temporal_sdk_core::{ClientOptions as CoreClientOptions, CoreRuntime, RetryClient};
 
 use bridge_macros::{TryFromJs, js_function};
-use temporal_client::{
-    ClientInitError, ConfiguredClient, TemporalServiceClientWithMetrics, WorkflowService,
-};
+use temporal_client::{ClientInitError, ConfiguredClient, TemporalServiceClientWithMetrics};
 
 use crate::runtime::Runtime;
 use crate::{helpers::*, runtime::RuntimeExt as _};
@@ -19,7 +17,22 @@ pub fn init(cx: &mut neon::prelude::ModuleContext) -> neon::prelude::NeonResult<
     cx.export_function("newClient", client_new)?;
     cx.export_function("clientUpdateHeaders", client_update_headers)?;
     cx.export_function("clientUpdateApiKey", client_update_api_key)?;
-    cx.export_function("clientSendRequest", client_send_request)?;
+    cx.export_function(
+        "clientSendWorkflowServiceRequest",
+        client_send_workflow_service_request,
+    )?;
+    cx.export_function(
+        "clientSendOperatorServiceRequest",
+        client_send_operator_service_request,
+    )?;
+    cx.export_function(
+        "clientSendTestServiceRequest",
+        client_send_test_service_request,
+    )?;
+    cx.export_function(
+        "clientSendHealthServiceRequest",
+        client_send_health_service_request,
+    )?;
     cx.export_function("clientClose", client_close)?;
 
     Ok(())
@@ -113,9 +126,9 @@ pub struct RpcCall {
     pub timeout: Option<Duration>,
 }
 
-/// Send a request using the provided Client
+/// Send a request to the Workflow Service using the provided Client
 #[js_function]
-pub fn client_send_request(
+pub fn client_send_workflow_service_request(
     client: OpaqueInboundHandle<Client>,
     call: RpcCall,
 ) -> BridgeResult<BridgeFuture<Vec<u8>>> {
@@ -124,7 +137,50 @@ pub fn client_send_request(
     let core_client = client.core_client.clone();
 
     // FIXME: "large future with a size of 18560 bytes"
-    core_runtime.future_to_promise(async move { client_invoke(core_client, call).await })
+    core_runtime
+        .future_to_promise(async move { client_invoke_workflow_service(core_client, call).await })
+}
+
+/// Send a request to the Operator Service using the provided Client
+#[js_function]
+pub fn client_send_operator_service_request(
+    client: OpaqueInboundHandle<Client>,
+    call: RpcCall,
+) -> BridgeResult<BridgeFuture<Vec<u8>>> {
+    let client = client.borrow()?;
+    let core_runtime = client.core_runtime.clone();
+    let core_client = client.core_client.clone();
+
+    core_runtime
+        .future_to_promise(async move { client_invoke_operator_service(core_client, call).await })
+}
+
+/// Send a request to the Test Service using the provided Client
+#[js_function]
+pub fn client_send_test_service_request(
+    client: OpaqueInboundHandle<Client>,
+    call: RpcCall,
+) -> BridgeResult<BridgeFuture<Vec<u8>>> {
+    let client = client.borrow()?;
+    let core_runtime = client.core_runtime.clone();
+    let core_client = client.core_client.clone();
+
+    core_runtime
+        .future_to_promise(async move { client_invoke_test_service(core_client, call).await })
+}
+
+/// Send a request to the Health Service using the provided Client
+#[js_function]
+pub fn client_send_health_service_request(
+    client: OpaqueInboundHandle<Client>,
+    call: RpcCall,
+) -> BridgeResult<BridgeFuture<Vec<u8>>> {
+    let client = client.borrow()?;
+    let core_runtime = client.core_runtime.clone();
+    let core_client = client.core_client.clone();
+
+    core_runtime
+        .future_to_promise(async move { client_invoke_health_service(core_client, call).await })
 }
 
 /// Indicates that a gRPC request failed
@@ -171,7 +227,12 @@ macro_rules! rpc_call {
 
 // FIXME: "this function may allocate 1400106 bytes on the stack"
 #[allow(clippy::too_many_lines)]
-async fn client_invoke(mut retry_client: CoreClient, call: RpcCall) -> BridgeResult<Vec<u8>> {
+async fn client_invoke_workflow_service(
+    mut retry_client: CoreClient,
+    call: RpcCall,
+) -> BridgeResult<Vec<u8>> {
+    use temporal_client::WorkflowService;
+
     match call.rpc.as_str() {
         "CountWorkflowExecutions" => {
             rpc_call!(retry_client, call, count_workflow_executions)
@@ -220,6 +281,7 @@ async fn client_invoke(mut retry_client: CoreClient, call: RpcCall) -> BridgeRes
             rpc_call!(retry_client, call, describe_workflow_rule)
         }
         "ExecuteMultiOperation" => rpc_call!(retry_client, call, execute_multi_operation),
+        "FetchWorkerConfig" => rpc_call!(retry_client, call, fetch_worker_config),
         "GetClusterInfo" => rpc_call!(retry_client, call, get_cluster_info),
         "GetCurrentDeployment" => rpc_call!(retry_client, call, get_current_deployment),
         "GetDeploymentReachability" => {
@@ -399,6 +461,7 @@ async fn client_invoke(mut retry_client: CoreClient, call: RpcCall) -> BridgeRes
             rpc_call!(retry_client, call, update_namespace)
         }
         "UpdateSchedule" => rpc_call!(retry_client, call, update_schedule),
+        "UpdateWorkerConfig" => rpc_call!(retry_client, call, update_worker_config),
         "UpdateWorkerDeploymentVersionMetadata" => {
             rpc_call!(
                 retry_client,
@@ -406,6 +469,9 @@ async fn client_invoke(mut retry_client: CoreClient, call: RpcCall) -> BridgeRes
                 update_worker_deployment_version_metadata
             )
         }
+        "UpdateTaskQueueConfig" => {
+            rpc_call!(retry_client, call, update_task_queue_config)
+        }
         "UpdateWorkflowExecution" => {
             rpc_call!(retry_client, call, update_workflow_execution)
         }
@@ -425,6 +491,83 @@ async fn client_invoke(mut retry_client: CoreClient, call: RpcCall) -> BridgeRes
     }
 }
 
+async fn client_invoke_operator_service(
+    mut retry_client: CoreClient,
+    call: RpcCall,
+) -> BridgeResult<Vec<u8>> {
+    use temporal_client::OperatorService;
+
+    match call.rpc.as_str() {
+        "AddOrUpdateRemoteCluster" => {
+            rpc_call!(retry_client, call, add_or_update_remote_cluster)
+        }
+        "AddSearchAttributes" => {
+            rpc_call!(retry_client, call, add_search_attributes)
+        }
+        "CreateNexusEndpoint" => rpc_call!(retry_client, call, create_nexus_endpoint),
+        "DeleteNamespace" => {
+            rpc_call!(retry_client, call, delete_namespace)
+        }
+        "DeleteNexusEndpoint" => rpc_call!(retry_client, call, delete_nexus_endpoint),
+        "GetNexusEndpoint" => rpc_call!(retry_client, call, get_nexus_endpoint),
+        "ListClusters" => rpc_call!(retry_client, call, list_clusters),
+        "ListNexusEndpoints" => rpc_call!(retry_client, call, list_nexus_endpoints),
+        "ListSearchAttributes" => {
+            rpc_call!(retry_client, call, list_search_attributes)
+        }
+        "RemoveRemoteCluster" => {
+            rpc_call!(retry_client, call, remove_remote_cluster)
+        }
+        "RemoveSearchAttributes" => {
+            rpc_call!(retry_client, call, remove_search_attributes)
+        }
+        "UpdateNexusEndpoint" => rpc_call!(retry_client, call, update_nexus_endpoint),
+        _ => Err(BridgeError::TypeError {
+            field: None,
+            message: format!("Unknown RPC call {}", call.rpc),
+        }),
+    }
+}
+
+async fn client_invoke_test_service(
+    mut retry_client: CoreClient,
+    call: RpcCall,
+) -> BridgeResult<Vec<u8>> {
+    use temporal_client::TestService;
+
+    match call.rpc.as_str() {
+        "GetCurrentTime" => rpc_call!(retry_client, call, get_current_time),
+        "LockTimeSkipping" => rpc_call!(retry_client, call, lock_time_skipping),
+        "SleepUntil" => rpc_call!(retry_client, call, sleep_until),
+        "Sleep" => rpc_call!(retry_client, call, sleep),
+        "UnlockTimeSkippingWithSleep" => {
+            rpc_call!(retry_client, call, unlock_time_skipping_with_sleep)
+        }
+        "UnlockTimeSkipping" => rpc_call!(retry_client, call, unlock_time_skipping),
+        _ => Err(BridgeError::TypeError {
+            field: None,
+            message: format!("Unknown RPC call {}", call.rpc),
+        }),
+    }
+}
+
+async fn client_invoke_health_service(
+    mut retry_client: CoreClient,
+    call: RpcCall,
+) -> BridgeResult<Vec<u8>> {
+    use temporal_client::HealthService;
+
+    match call.rpc.as_str() {
+        "Check" => rpc_call!(retry_client, call, check),
+        // Intentionally ignore 'watch' because it's a streaming method, which is not currently
+        // supported by the macro and client-side code, and not needed anyway for any SDK use case.
+        _ => Err(BridgeError::TypeError {
+            field: None,
+            message: format!("Unknown RPC call {}", call.rpc),
+        }),
+    }
+}
+
 fn rpc_req<P: prost::Message + Default>(call: RpcCall) -> BridgeResult<tonic::Request<P>> {
     let proto = P::decode(&*call.req).map_err(|err| BridgeError::TypeError {
         field: None,

package/src/worker.rs

@@ -10,12 +10,12 @@ use temporal_sdk_core::{
     CoreRuntime,
     api::{
         Worker as CoreWorkerTrait,
-        errors::{CompleteActivityError, CompleteWfError, PollError},
+        errors::{CompleteActivityError, CompleteNexusError, CompleteWfError, PollError},
     },
     init_replay_worker, init_worker,
     protos::{
         coresdk::{
-            ActivityHeartbeat, ActivityTaskCompletion,
+            ActivityHeartbeat, ActivityTaskCompletion, nexus::NexusTaskCompletion,
             workflow_completion::WorkflowActivationCompletion,
         },
         temporal::api::history::v1::History,
@@ -52,6 +52,9 @@ pub fn init(cx: &mut ModuleContext) -> NeonResult<()> {
         worker_record_activity_heartbeat,
     )?;
 
+    cx.export_function("workerPollNexusTask", worker_poll_nexus_task)?;
+    cx.export_function("workerCompleteNexusTask", worker_complete_nexus_task)?;
+
     cx.export_function("workerInitiateShutdown", worker_initiate_shutdown)?;
     cx.export_function("workerFinalizeShutdown", worker_finalize_shutdown)?;
 
@@ -247,6 +250,63 @@ pub fn worker_record_activity_heartbeat(
     Ok(())
 }
 
+/// Initiate a single nexus task poll request.
+/// There should be only one concurrent poll request for this type.
+#[js_function]
+pub fn worker_poll_nexus_task(
+    worker: OpaqueInboundHandle<Worker>,
+) -> BridgeResult<BridgeFuture<Vec<u8>>> {
+    let worker_ref = worker.borrow()?;
+    let worker = worker_ref.core_worker.clone();
+    let runtime = worker_ref.core_runtime.clone();
+
+    runtime.future_to_promise(async move {
+        let result = worker.poll_nexus_task().await;
+
+        match result {
+            Ok(task) => Ok(task.encode_to_vec()),
+            Err(err) => match err {
+                PollError::ShutDown => Err(BridgeError::WorkerShutdown)?,
+                PollError::TonicError(status) => {
+                    Err(BridgeError::TransportError(status.message().to_string()))?
+                }
+            },
+        }
+    })
+}
+
+/// Submit an nexus task completion to core.
+#[js_function]
+pub fn worker_complete_nexus_task(
+    worker: OpaqueInboundHandle<Worker>,
+    completion: Vec<u8>,
+) -> BridgeResult<BridgeFuture<()>> {
+    let nexus_completion = NexusTaskCompletion::decode_length_delimited(completion.as_slice())
+        .map_err(|err| BridgeError::TypeError {
+            field: None,
+            message: format!("Cannot decode Completion from buffer: {err:?}"),
+        })?;
+
+    let worker_ref = worker.borrow()?;
+    let worker = worker_ref.core_worker.clone();
+    let runtime = worker_ref.core_runtime.clone();
+
+    runtime.future_to_promise(async move {
+        worker
+            .complete_nexus_task(nexus_completion)
+            .await
+            .map_err(|err| match err {
+                CompleteNexusError::NexusNotEnabled {} => {
+                    BridgeError::UnexpectedError(format!("{err}"))
+                }
+                CompleteNexusError::MalformedNexusCompletion { reason } => BridgeError::TypeError {
+                    field: None,
+                    message: format!("Malformed nexus Completion: {reason:?}"),
+                },
+            })
+    })
+}
+
 /// Request shutdown of the worker.
 /// Once complete Core will stop polling on new tasks and activations on worker's task queue.
 /// Caller should drain any pending tasks and activations and call worker_finalize_shutdown before breaking from
@@ -410,9 +470,9 @@ mod config {
         ResourceBasedSlotsOptions, ResourceBasedSlotsOptionsBuilder, ResourceSlotOptions,
         SlotSupplierOptions as CoreSlotSupplierOptions, TunerHolder, TunerHolderOptionsBuilder,
         api::worker::{
-            ActivitySlotKind, LocalActivitySlotKind, PollerBehavior as CorePollerBehavior,
-            SlotKind, WorkerConfig, WorkerConfigBuilder, WorkerConfigBuilderError,
-            WorkerDeploymentOptions as CoreWorkerDeploymentOptions,
+            ActivitySlotKind, LocalActivitySlotKind, NexusSlotKind,
+            PollerBehavior as CorePollerBehavior, SlotKind, WorkerConfig, WorkerConfigBuilder,
+            WorkerConfigBuilderError, WorkerDeploymentOptions as CoreWorkerDeploymentOptions,
             WorkerDeploymentVersion as CoreWorkerDeploymentVersion, WorkflowSlotKind,
         },
         protos::temporal::api::enums::v1::VersioningBehavior as CoreVersioningBehavior,
@@ -439,6 +499,7 @@ mod config {
         non_sticky_to_sticky_poll_ratio: f32,
         workflow_task_poller_behavior: PollerBehavior,
         activity_task_poller_behavior: PollerBehavior,
+        nexus_task_poller_behavior: PollerBehavior,
         enable_non_local_activities: bool,
         sticky_queue_schedule_to_start_timeout: Duration,
         max_cached_workflows: usize,
@@ -505,6 +566,7 @@ mod config {
                 .nonsticky_to_sticky_poll_ratio(self.non_sticky_to_sticky_poll_ratio)
                 .workflow_task_poller_behavior(self.workflow_task_poller_behavior)
                 .activity_task_poller_behavior(self.activity_task_poller_behavior)
+                .nexus_task_poller_behavior(self.nexus_task_poller_behavior)
                 .no_remote_activities(!self.enable_non_local_activities)
                 .sticky_queue_schedule_to_start_timeout(self.sticky_queue_schedule_to_start_timeout)
                 .max_cached_workflows(self.max_cached_workflows)
@@ -590,6 +652,7 @@ mod config {
         workflow_task_slot_supplier: SlotSupplier<WorkflowSlotKind>,
         activity_task_slot_supplier: SlotSupplier<ActivitySlotKind>,
         local_activity_task_slot_supplier: SlotSupplier<LocalActivitySlotKind>,
+        nexus_task_slot_supplier: SlotSupplier<NexusSlotKind>,
     }
 
     impl WorkerTuner {
@@ -609,6 +672,10 @@ mod config {
                 self.local_activity_task_slot_supplier
                     .into_slot_supplier(&mut rbo),
             );
+            tuner_holder.nexus_slot_options(
+                self.nexus_task_slot_supplier
+                    .into_slot_supplier(&mut rbo)
+            );
             if let Some(rbo) = rbo {
                 tuner_holder.resource_based_options(rbo);
             }

package/ts/native.ts

@@ -104,7 +104,13 @@ export declare function clientUpdateHeaders(client: Client, headers: Record<stri
 
 export declare function clientUpdateApiKey(client: Client, apiKey: string): void;
 
-export declare function clientSendRequest(client: Client, call: RpcCall): Promise<Buffer>;
+export declare function clientSendWorkflowServiceRequest(client: Client, call: RpcCall): Promise<Buffer>;
+
+export declare function clientSendOperatorServiceRequest(client: Client, call: RpcCall): Promise<Buffer>;
+
+export declare function clientSendTestServiceRequest(client: Client, call: RpcCall): Promise<Buffer>;
+
+export declare function clientSendHealthServiceRequest(client: Client, call: RpcCall): Promise<Buffer>;
 
 export declare function clientClose(client: Client): void;
 
@@ -173,6 +179,10 @@ export declare function workerCompleteActivityTask(worker: Worker, result: Buffe
 
 export declare function workerRecordActivityHeartbeat(worker: Worker, heartbeat: Buffer): void;
 
+export declare function workerPollNexusTask(worker: Worker): Promise<Buffer>;
+
+export declare function workerCompleteNexusTask(worker: Worker, result: Buffer): Promise<void>;
+
 export declare function workerInitiateShutdown(worker: Worker): void;
 
 export declare function workerFinalizeShutdown(worker: Worker): Promise<void>;
@@ -192,6 +202,7 @@ export interface WorkerOptions {
   nonStickyToStickyPollRatio: number;
   workflowTaskPollerBehavior: PollerBehavior;
   activityTaskPollerBehavior: PollerBehavior;
+  nexusTaskPollerBehavior: PollerBehavior;
   enableNonLocalActivities: boolean;
   stickyQueueScheduleToStartTimeout: number;
   maxCachedWorkflows: number;
@@ -235,6 +246,7 @@ export interface WorkerTunerOptions {
   workflowTaskSlotSupplier: SlotSupplierOptions;
   activityTaskSlotSupplier: SlotSupplierOptions;
   localActivityTaskSlotSupplier: SlotSupplierOptions;
+  nexusTaskSlotSupplier: SlotSupplierOptions;
 }
 
 export type SlotSupplierOptions =