@temporalio/core-bridge 0.19.2 → 0.20.2

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

@@ -7,9 +7,11 @@ mod determinism;
 mod local_activities;
 mod patches;
 mod replay;
+mod resets;
 mod signals;
 mod stickyness;
 mod timers;
+mod upsert_search_attrs;
 
 use assert_matches::assert_matches;
 use futures::{channel::mpsc::UnboundedReceiver, future, SinkExt, StreamExt};
@@ -21,8 +23,9 @@ use std::{
     },
     time::Duration,
 };
+use temporal_client::{WorkflowClientTrait, WorkflowOptions};
 use temporal_sdk::{WfContext, WorkflowResult};
-use temporal_sdk_core_api::{errors::PollWfError, Core};
+use temporal_sdk_core_api::{errors::PollWfError, Worker};
 use temporal_sdk_core_protos::{
     coresdk::{
         activity_result::ActivityExecutionResult,
@@ -35,7 +38,7 @@ use temporal_sdk_core_protos::{
 };
 use temporal_sdk_core_test_utils::{
     history_from_proto_binary, init_core_and_create_wf, init_core_replay_preloaded,
-    schedule_activity_cmd, CoreTestHelpers, CoreWfStarter,
+    schedule_activity_cmd, CoreWfStarter, WorkerTestHelpers,
 };
 use tokio::time::sleep;
 use uuid::Uuid;
@@ -46,19 +49,18 @@ use uuid::Uuid;
 #[tokio::test]
 async fn parallel_workflows_same_queue() {
     let mut starter = CoreWfStarter::new("parallel_workflows_same_queue");
-    let core = starter.get_core().await;
-    let task_q = starter.get_task_queue().to_string();
+    let core = starter.get_worker().await;
     let num_workflows = 25usize;
 
     let run_ids: Vec<_> = future::join_all(
-        (0..num_workflows).map(|i| starter.start_wf_with_id(format!("wf-id-{}", i))),
+        (0..num_workflows)
+            .map(|i| starter.start_wf_with_id(format!("wf-id-{}", i), WorkflowOptions::default())),
     )
     .await;
 
     let mut send_chans = HashMap::new();
     async fn wf_task(
-        core: Arc<dyn Core>,
-        task_q: String,
+        worker: Arc<dyn Worker>,
         mut task_chan: UnboundedReceiver<WorkflowActivation>,
     ) {
         let task = task_chan.next().await.unwrap();
@@ -68,10 +70,11 @@ async fn parallel_workflows_same_queue() {
                 variant: Some(workflow_activation_job::Variant::StartWorkflow(_)),
             }]
         );
-        core.complete_timer(&task_q, &task.run_id, 1, Duration::from_secs(1))
+        worker
+            .complete_timer(&task.run_id, 1, Duration::from_secs(1))
             .await;
         let task = task_chan.next().await.unwrap();
-        core.complete_execution(&task_q, &task.run_id).await;
+        worker.complete_execution(&task.run_id).await;
     }
 
     let handles: Vec<_> = run_ids
@@ -79,12 +82,12 @@ async fn parallel_workflows_same_queue() {
         .map(|run_id| {
             let (tx, rx) = futures::channel::mpsc::unbounded();
             send_chans.insert(run_id.clone(), tx);
-            tokio::spawn(wf_task(core.clone(), task_q.clone(), rx))
+            tokio::spawn(wf_task(core.clone(), rx))
         })
         .collect();
 
     for _ in 0..num_workflows * 2 {
-        let task = core.poll_workflow_activation(&task_q).await.unwrap();
+        let task = core.poll_workflow_activation().await.unwrap();
         send_chans
             .get(&task.run_id)
             .unwrap()
@@ -120,6 +123,7 @@ async fn workflow_lru_cache_evictions() {
                 format!("wce-{}", Uuid::new_v4()),
                 wf_type.to_string(),
                 vec![],
+                WorkflowOptions::default(),
             )
             .await
             .unwrap();
@@ -136,8 +140,7 @@ async fn workflow_lru_cache_evictions() {
 #[tokio::test]
 async fn shutdown_aborts_actively_blocked_poll() {
     let mut starter = CoreWfStarter::new("shutdown_aborts_actively_blocked_poll");
-    let core = starter.get_core().await;
-    let task_q = starter.get_task_queue();
+    let core = starter.get_worker().await;
     // Begin the poll, and request shutdown from another thread after a small period of time.
     let tcore = core.clone();
     let handle = tokio::spawn(async move {
@@ -145,14 +148,14 @@ async fn shutdown_aborts_actively_blocked_poll() {
         tcore.shutdown().await;
     });
     assert_matches!(
-        core.poll_workflow_activation(task_q).await.unwrap_err(),
+        core.poll_workflow_activation().await.unwrap_err(),
         PollWfError::ShutDown
     );
     handle.await.unwrap();
     // Ensure double-shutdown doesn't explode
     core.shutdown().await;
     assert_matches!(
-        core.poll_workflow_activation(task_q).await.unwrap_err(),
+        core.poll_workflow_activation().await.unwrap_err(),
         PollWfError::ShutDown
     );
 }
@@ -160,25 +163,26 @@ async fn shutdown_aborts_actively_blocked_poll() {
 #[rstest::rstest]
 #[tokio::test]
 async fn fail_wf_task(#[values(true, false)] replay: bool) {
-    let (core, task_q) = if replay {
-        init_core_replay_preloaded(
+    let core = if replay {
+        let (core, _) = init_core_replay_preloaded(
             "fail_wf_task",
             &history_from_proto_binary("histories/fail_wf_task.bin")
                 .await
                 .unwrap(),
-        )
+        );
+        core
     } else {
-        init_core_and_create_wf("fail_wf_task").await
+        let mut starter = init_core_and_create_wf("fail_wf_task").await;
+        starter.get_worker().await
     };
     // Start with a timer
-    let task = core.poll_workflow_activation(&task_q).await.unwrap();
-    core.complete_timer(&task_q, &task.run_id, 0, Duration::from_millis(200))
+    let task = core.poll_workflow_activation().await.unwrap();
+    core.complete_timer(&task.run_id, 0, Duration::from_millis(200))
         .await;
 
     // Then break for whatever reason
-    let task = core.poll_workflow_activation(&task_q).await.unwrap();
+    let task = core.poll_workflow_activation().await.unwrap();
     core.complete_workflow_activation(WorkflowActivationCompletion::fail(
-        &task_q,
         task.run_id,
         Failure::application_failure("I did an oopsie".to_string(), false),
     ))
@@ -187,7 +191,7 @@ async fn fail_wf_task(#[values(true, false)] replay: bool) {
 
     // The server will want to retry the task. This time we finish the workflow -- but we need
     // to poll a couple of times as there will be more than one required workflow activation.
-    let task = core.poll_workflow_activation(&task_q).await.unwrap();
+    let task = core.poll_workflow_activation().await.unwrap();
     // The first poll response will tell us to evict
     assert_matches!(
         task.jobs.as_slice(),
@@ -195,13 +199,12 @@ async fn fail_wf_task(#[values(true, false)] replay: bool) {
             variant: Some(workflow_activation_job::Variant::RemoveFromCache(_)),
         }]
     );
-    core.complete_workflow_activation(WorkflowActivationCompletion::empty(&task_q, task.run_id))
+    core.complete_workflow_activation(WorkflowActivationCompletion::empty(task.run_id))
         .await
         .unwrap();
 
-    let task = core.poll_workflow_activation(&task_q).await.unwrap();
+    let task = core.poll_workflow_activation().await.unwrap();
     core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
-        &task_q,
         task.run_id,
         vec![StartTimer {
             seq: 0,
@@ -211,19 +214,21 @@ async fn fail_wf_task(#[values(true, false)] replay: bool) {
     ))
     .await
     .unwrap();
-    let task = core.poll_workflow_activation(&task_q).await.unwrap();
-    core.complete_execution(&task_q, &task.run_id).await;
+    let task = core.poll_workflow_activation().await.unwrap();
+    core.complete_execution(&task.run_id).await;
 }
 
 #[tokio::test]
 async fn fail_workflow_execution() {
-    let (core, task_q) = init_core_and_create_wf("fail_workflow_execution").await;
-    let task = core.poll_workflow_activation(&task_q).await.unwrap();
-    core.complete_timer(&task_q, &task.run_id, 0, Duration::from_secs(1))
+    let core = init_core_and_create_wf("fail_workflow_execution")
+        .await
+        .get_worker()
+        .await;
+    let task = core.poll_workflow_activation().await.unwrap();
+    core.complete_timer(&task.run_id, 0, Duration::from_secs(1))
         .await;
-    let task = core.poll_workflow_activation(&task_q).await.unwrap();
+    let task = core.poll_workflow_activation().await.unwrap();
     core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
-        &task_q,
         task.run_id,
         vec![FailWorkflowExecution {
             failure: Some(Failure::application_failure("I'm ded".to_string(), false)),
@@ -236,15 +241,16 @@ async fn fail_workflow_execution() {
 
 #[tokio::test]
 async fn signal_workflow() {
-    let (core, task_q) = init_core_and_create_wf("signal_workflow").await;
-    let workflow_id = task_q.clone();
+    let mut starter = init_core_and_create_wf("signal_workflow").await;
+    let core = starter.get_worker().await;
+    let client = starter.get_client().await;
+    let workflow_id = starter.get_task_queue().to_string();
 
     let signal_id_1 = "signal1";
     let signal_id_2 = "signal2";
-    let res = core.poll_workflow_activation(&task_q).await.unwrap();
+    let res = core.poll_workflow_activation().await.unwrap();
     // Task is completed with no commands
     core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
-        &task_q,
         res.run_id.clone(),
         vec![],
     ))
@@ -252,7 +258,7 @@ async fn signal_workflow() {
     .unwrap();
 
     // Send the signals to the server
-    core.server_gateway()
+    client
         .signal_workflow_execution(
             workflow_id.to_string(),
             res.run_id.to_string(),
@@ -261,7 +267,7 @@ async fn signal_workflow() {
         )
         .await
         .unwrap();
-    core.server_gateway()
+    client
         .signal_workflow_execution(
             workflow_id.to_string(),
             res.run_id.to_string(),
@@ -271,7 +277,7 @@ async fn signal_workflow() {
         .await
         .unwrap();
 
-    let mut res = core.poll_workflow_activation(&task_q).await.unwrap();
+    let mut res = core.poll_workflow_activation().await.unwrap();
     // Sometimes both signals are complete at once, sometimes only one, depending on server
     // Converting test to wf function type would make this shorter
     if res.jobs.len() == 2 {
@@ -294,13 +300,12 @@ async fn signal_workflow() {
             },]
         );
         core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
-            &task_q,
             res.run_id,
             vec![],
         ))
         .await
         .unwrap();
-        res = core.poll_workflow_activation(&task_q).await.unwrap();
+        res = core.poll_workflow_activation().await.unwrap();
         assert_matches!(
             res.jobs.as_slice(),
             [WorkflowActivationJob {
@@ -308,20 +313,20 @@ async fn signal_workflow() {
             },]
         );
     }
-    core.complete_execution(&task_q, &res.run_id).await;
+    core.complete_execution(&res.run_id).await;
 }
 
 #[tokio::test]
 async fn signal_workflow_signal_not_handled_on_workflow_completion() {
-    let (core, task_q) =
+    let mut starter =
         init_core_and_create_wf("signal_workflow_signal_not_handled_on_workflow_completion").await;
-    let workflow_id = task_q.as_str();
+    let core = starter.get_worker().await;
+    let workflow_id = starter.get_task_queue().to_string();
     let signal_id_1 = "signal1";
     for i in 1..=2 {
-        let res = core.poll_workflow_activation(&task_q).await.unwrap();
+        let res = core.poll_workflow_activation().await.unwrap();
         // Task is completed with a timer
         core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
-            &task_q,
             res.run_id,
             vec![StartTimer {
                 seq: 0,
@@ -332,7 +337,7 @@ async fn signal_workflow_signal_not_handled_on_workflow_completion() {
         .await
         .unwrap();
 
-        let res = core.poll_workflow_activation(&task_q).await.unwrap();
+        let res = core.poll_workflow_activation().await.unwrap();
 
         if i == 1 {
             // First attempt we should only see the timer being fired
@@ -346,9 +351,11 @@ async fn signal_workflow_signal_not_handled_on_workflow_completion() {
             let run_id = res.run_id.clone();
 
             // Send the signal to the server
-            core.server_gateway()
+            starter
+                .get_client()
+                .await
                 .signal_workflow_execution(
-                    workflow_id.to_string(),
+                    workflow_id.clone(),
                     res.run_id.to_string(),
                     signal_id_1.to_string(),
                     None,
@@ -358,22 +365,19 @@ async fn signal_workflow_signal_not_handled_on_workflow_completion() {
 
             // Send completion - not having seen a poll response with a signal in it yet (unhandled
             // command error will be logged as a warning and an eviction will be issued)
-            core.complete_execution(&task_q, &run_id).await;
+            core.complete_execution(&run_id).await;
 
             // We should be told to evict
-            let res = core.poll_workflow_activation(&task_q).await.unwrap();
+            let res = core.poll_workflow_activation().await.unwrap();
             assert_matches!(
                 res.jobs.as_slice(),
                 [WorkflowActivationJob {
                     variant: Some(workflow_activation_job::Variant::RemoveFromCache(_)),
                 }]
             );
-            core.complete_workflow_activation(WorkflowActivationCompletion::empty(
-                task_q.clone(),
-                res.run_id,
-            ))
-            .await
-            .unwrap();
+            core.complete_workflow_activation(WorkflowActivationCompletion::empty(res.run_id))
+                .await
+                .unwrap();
             // Loop to the top to handle wf from the beginning
             continue;
         }
@@ -390,7 +394,7 @@ async fn signal_workflow_signal_not_handled_on_workflow_completion() {
                 }
             ]
         );
-        core.complete_execution(&task_q, &res.run_id).await;
+        core.complete_execution(&res.run_id).await;
     }
 }
 
@@ -404,13 +408,14 @@ async fn wft_timeout_doesnt_create_unsolvable_autocomplete() {
         // Test needs eviction on and a short timeout
         .max_cached_workflows(0usize)
         .wft_timeout(Duration::from_secs(1));
-    let core = wf_starter.get_core().await;
+    let core = wf_starter.get_worker().await;
+    let client = wf_starter.get_client().await;
     let task_q = wf_starter.get_task_queue();
     let wf_id = &wf_starter.get_wf_id().to_owned();
 
     // Set up some helpers for polling and completing
     let poll_sched_act = || async {
-        let wf_task = core.poll_workflow_activation(task_q).await.unwrap();
+        let wf_task = core.poll_workflow_activation().await.unwrap();
         core.complete_workflow_activation(
             schedule_activity_cmd(
                 0,
@@ -420,7 +425,7 @@ async fn wft_timeout_doesnt_create_unsolvable_autocomplete() {
                 Duration::from_secs(60),
                 Duration::from_secs(60),
             )
-            .into_completion(task_q.to_string(), wf_task.run_id.clone()),
+            .into_completion(wf_task.run_id.clone()),
         )
         .await
         .unwrap();
@@ -428,7 +433,7 @@ async fn wft_timeout_doesnt_create_unsolvable_autocomplete() {
     };
     let poll_sched_act_poll = || async {
         poll_sched_act().await;
-        let wf_task = core.poll_workflow_activation(task_q).await.unwrap();
+        let wf_task = core.poll_workflow_activation().await.unwrap();
         assert_matches!(
             wf_task.jobs.as_slice(),
             [
@@ -452,36 +457,35 @@ async fn wft_timeout_doesnt_create_unsolvable_autocomplete() {
     let wf_task = poll_sched_act().await;
     // Before polling for a task again, we start and complete the activity and send the
     // corresponding signals.
-    let ac_task = core.poll_activity_task(task_q).await.unwrap();
+    let ac_task = core.poll_activity_task().await.unwrap();
     let rid = wf_task.run_id.clone();
     // Send the signals to the server & resolve activity -- sometimes this happens too fast
     sleep(Duration::from_millis(200)).await;
-    core.server_gateway()
+    client
         .signal_workflow_execution(wf_id.to_string(), rid, signal_at_start.to_string(), None)
         .await
         .unwrap();
     // Complete activity successfully.
     core.complete_activity_task(ActivityTaskCompletion {
         task_token: ac_task.task_token,
-        task_queue: task_q.to_string(),
         result: Some(ActivityExecutionResult::ok(Default::default())),
     })
     .await
     .unwrap();
     let rid = wf_task.run_id.clone();
-    core.server_gateway()
+    client
         .signal_workflow_execution(wf_id.to_string(), rid, signal_at_complete.to_string(), None)
         .await
         .unwrap();
     // Now poll again, it will be an eviction b/c non-sticky mode.
-    let wf_task = core.poll_workflow_activation(task_q).await.unwrap();
+    let wf_task = core.poll_workflow_activation().await.unwrap();
     assert_matches!(
         wf_task.jobs.as_slice(),
         [WorkflowActivationJob {
             variant: Some(workflow_activation_job::Variant::RemoveFromCache(_)),
         }]
     );
-    core.complete_workflow_activation(WorkflowActivationCompletion::empty(task_q, wf_task.run_id))
+    core.complete_workflow_activation(WorkflowActivationCompletion::empty(wf_task.run_id))
         .await
         .unwrap();
     // Start from the beginning
@@ -491,11 +495,11 @@ async fn wft_timeout_doesnt_create_unsolvable_autocomplete() {
     // Poll again, which should not have any work to do and spin, until the complete goes through.
     // Which will be rejected with not found, producing an eviction.
     let (wf_task, _) = tokio::join!(
-        async { core.poll_workflow_activation(task_q).await.unwrap() },
+        async { core.poll_workflow_activation().await.unwrap() },
         async {
             sleep(Duration::from_millis(500)).await;
             // Reply to the first one, finally
-            core.complete_execution(task_q, &wf_task.run_id).await;
+            core.complete_execution(&wf_task.run_id).await;
         }
     );
     assert_matches!(
@@ -504,10 +508,10 @@ async fn wft_timeout_doesnt_create_unsolvable_autocomplete() {
             variant: Some(workflow_activation_job::Variant::RemoveFromCache(_)),
         }]
     );
-    core.complete_workflow_activation(WorkflowActivationCompletion::empty(task_q, wf_task.run_id))
+    core.complete_workflow_activation(WorkflowActivationCompletion::empty(wf_task.run_id))
         .await
         .unwrap();
     // Do it all over again, without timing out this time
     let wf_task = poll_sched_act_poll().await;
-    core.complete_execution(task_q, &wf_task.run_id).await;
+    core.complete_execution(&wf_task.run_id).await;
 }

package/sdk-core/tests/load_tests.rs

@@ -1,6 +1,7 @@
 use assert_matches::assert_matches;
 use futures::future::join_all;
 use std::time::{Duration, Instant};
+use temporal_client::WorkflowOptions;
 use temporal_sdk::{ActivityOptions, WfContext};
 use temporal_sdk_core_protos::coresdk::{
     activity_result::ActivityExecutionResult, activity_task::activity_task as act_task,
@@ -19,7 +20,6 @@ async fn activity_load() {
         .max_at_polls(10)
         .max_at(CONCURRENCY);
     let mut worker = starter.worker().await;
-    let task_q = starter.get_task_queue().to_owned();
 
     let activity_id = "act-1";
     let activity_timeout = Duration::from_secs(8);
@@ -57,7 +57,12 @@ async fn activity_load() {
         let wf_id = format!("activity_load_{}", i);
         async move {
             worker
-                .submit_wf(wf_id, wf_type.to_owned(), vec![])
+                .submit_wf(
+                    wf_id,
+                    wf_type.to_owned(),
+                    vec![],
+                    WorkflowOptions::default(),
+                )
                 .await
                 .unwrap();
         }
@@ -66,15 +71,14 @@ async fn activity_load() {
     dbg!(starting.elapsed());
 
     let running = Instant::now();
-    let core = starter.get_core().await;
+    let core = starter.get_worker().await;
 
     // Poll for and complete all activities
     let c2 = core.clone();
     let all_acts = async move {
         let mut act_complete_futs = vec![];
         for _ in 0..CONCURRENCY {
-            let task_q = task_q.clone();
-            let task = c2.poll_activity_task(&task_q).await.unwrap();
+            let task = c2.poll_activity_task().await.unwrap();
             assert_matches!(
                 task.variant,
                 Some(act_task::Variant::Start(ref start_activity)) => {
@@ -86,7 +90,6 @@ async fn activity_load() {
             act_complete_futs.push(tokio::spawn(async move {
                 core.complete_activity_task(ActivityTaskCompletion {
                     task_token: task.task_token,
-                    task_queue: task_q,
                     result: Some(ActivityExecutionResult::ok(pd.into())),
                 })
                 .await

package/sdk-core/tests/main.rs

@@ -2,19 +2,53 @@
 
 #[cfg(test)]
 mod integ_tests {
-    use std::str::FromStr;
-    use temporal_sdk_core::{
-        ClientTlsConfig, ServerGatewayApis, ServerGatewayOptionsBuilder, TlsConfig,
-    };
-    use temporal_sdk_core_test_utils::NAMESPACE;
-    use url::Url;
-
     mod client_tests;
     mod heartbeat_tests;
     mod polling_tests;
     mod queries_tests;
     mod workflow_tests;
 
+    use std::str::FromStr;
+    use temporal_client::WorkflowService;
+    use temporal_sdk_core::{
+        init_worker, telemetry_init, ClientOptionsBuilder, ClientTlsConfig, TlsConfig,
+        WorkflowClientTrait,
+    };
+    use temporal_sdk_core_api::{worker::WorkerConfigBuilder, CoreTelemetry};
+    use temporal_sdk_core_protos::temporal::api::workflowservice::v1::ListNamespacesRequest;
+    use temporal_sdk_core_test_utils::{
+        get_integ_server_options, get_integ_telem_options, NAMESPACE,
+    };
+    use url::Url;
+
+    // Create a worker like a bridge would (unwraps aside)
+    #[tokio::test]
+    #[ignore] // Really a compile time check more than anything
+    async fn lang_bridge_example() {
+        let opts = get_integ_server_options();
+        let telem_d = telemetry_init(&get_integ_telem_options()).unwrap();
+        let mut retrying_client = opts
+            .connect_no_namespace(telem_d.get_metric_meter())
+            .await
+            .unwrap();
+
+        let _worker = init_worker(
+            WorkerConfigBuilder::default()
+                .namespace("default")
+                .task_queue("Wheee!")
+                .build()
+                .unwrap(),
+            // clone the client if you intend to use it later. Strip off the retry wrapper since
+            // worker will assert its own
+            retrying_client.clone(),
+        );
+
+        // Do things with worker or client
+        let _ = retrying_client
+            .list_namespaces(ListNamespacesRequest::default())
+            .await;
+    }
+
     // TODO: Currently ignored because starting up the docker image with TLS requires some hoop
     //  jumping. We should upgrade CI to be able to do that but this was manually run against
     //  https://github.com/temporalio/customization-samples/tree/master/tls/tls-simple
@@ -37,9 +71,8 @@ mod integ_tests {
         )
         .await
         .unwrap();
-        let sgo = ServerGatewayOptionsBuilder::default()
+        let sgo = ClientOptionsBuilder::default()
             .target_url(Url::from_str("https://localhost:7233").unwrap())
-            .namespace(NAMESPACE.to_string())
             .worker_binary_id("binident".to_string())
             .tls_cfg(TlsConfig {
                 server_root_ca_cert: Some(root),
@@ -51,7 +84,7 @@ mod integ_tests {
             })
             .build()
             .unwrap();
-        let con = sgo.connect(None).await.unwrap();
+        let con = sgo.connect(NAMESPACE.to_string(), None).await.unwrap();
         con.list_namespaces().await.unwrap();
     }
 }

package/src/conversions.rs

@@ -9,8 +9,8 @@ use opentelemetry::trace::{SpanContext, SpanId, TraceFlags, TraceId, TraceState}
 use std::{fmt::Display, net::SocketAddr, str::FromStr, time::Duration};
 use temporal_sdk_core::{
     api::worker::{WorkerConfig, WorkerConfigBuilder},
-    ClientTlsConfig, RetryConfig, ServerGatewayOptions, ServerGatewayOptionsBuilder,
-    TelemetryOptions, TelemetryOptionsBuilder, TlsConfig, Url,
+    ClientOptions, ClientOptionsBuilder, ClientTlsConfig, RetryConfig, TelemetryOptions,
+    TelemetryOptionsBuilder, TlsConfig, Url,
 };
 
 macro_rules! js_value_getter {
@@ -105,10 +105,7 @@ where
 
 pub(crate) trait ObjectHandleConversionsExt {
     fn as_otel_span_context(&self, ctx: &mut FunctionContext) -> NeonResult<SpanContext>;
-    fn as_server_gateway_options(
-        &self,
-        ctx: &mut FunctionContext,
-    ) -> NeonResult<ServerGatewayOptions>;
+    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>;
 }
@@ -127,10 +124,7 @@ impl ObjectHandleConversionsExt for Handle<'_, JsObject> {
         ))
     }
 
-    fn as_server_gateway_options(
-        &self,
-        cx: &mut FunctionContext,
-    ) -> NeonResult<ServerGatewayOptions> {
+    fn as_client_options(&self, cx: &mut FunctionContext) -> NeonResult<ClientOptions> {
         let url = match Url::parse(&js_value_getter!(cx, self, "url", JsString)) {
             Ok(url) => url,
             // Note that address is what's used in the Node side.
@@ -204,7 +198,7 @@ impl ObjectHandleConversionsExt for Handle<'_, JsObject> {
             },
         };
 
-        let mut gateway_opts = ServerGatewayOptionsBuilder::default();
+        let mut gateway_opts = ClientOptionsBuilder::default();
         if let Some(tls_cfg) = tls_cfg {
             gateway_opts.tls_cfg(tls_cfg);
         }
@@ -212,7 +206,6 @@ impl ObjectHandleConversionsExt for Handle<'_, JsObject> {
             .client_name("temporal-typescript".to_string())
             .client_version(js_value_getter!(cx, self, "sdkVersion", JsString))
             .target_url(url)
-            .namespace(js_value_getter!(cx, self, "namespace", JsString))
             .identity(js_value_getter!(cx, self, "identity", JsString))
             .worker_binary_id(js_value_getter!(cx, self, "workerBinaryId", JsString))
             .retry_config(retry_config)
@@ -255,6 +248,7 @@ impl ObjectHandleConversionsExt for Handle<'_, JsObject> {
     }
 
     fn as_worker_config(&self, cx: &mut FunctionContext) -> NeonResult<WorkerConfig> {
+        let namespace = js_value_getter!(cx, self, "namespace", JsString);
         let task_queue = js_value_getter!(cx, self, "taskQueue", JsString);
         let max_outstanding_activities =
             js_value_getter!(cx, self, "maxConcurrentActivityTaskExecutions", JsNumber) as usize;
@@ -298,6 +292,7 @@ impl ObjectHandleConversionsExt for Handle<'_, JsObject> {
             .max_cached_workflows(max_cached_workflows)
             .nonsticky_to_sticky_poll_ratio(nonsticky_to_sticky_poll_ratio)
             .sticky_queue_schedule_to_start_timeout(sticky_queue_schedule_to_start_timeout)
+            .namespace(namespace)
             .task_queue(task_queue)
             .max_heartbeat_throttle_interval(max_heartbeat_throttle_interval)
             .default_heartbeat_throttle_interval(default_heartbeat_throttle_interval)