@temporalio/core-bridge 1.13.0 → 1.13.2

package/sdk-core/core/src/worker/workflow/machines/signal_external_state_machine.rs

@@ -293,142 +293,3 @@ impl SignalExternalMachine {
         matches!(self.state(), SignalExternalMachineState::Cancelled(_))
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::{
-        replay::TestHistoryBuilder,
-        test_help::{MockPollCfg, build_fake_sdk},
-    };
-    use std::mem::discriminant;
-    use temporal_sdk::{CancellableFuture, SignalWorkflowOptions, WfContext, WorkflowResult};
-    use temporal_sdk_core_protos::{
-        DEFAULT_WORKFLOW_TYPE,
-        coresdk::workflow_activation::{WorkflowActivationJob, workflow_activation_job},
-        temporal::api::command::v1::Command,
-    };
-    use temporal_sdk_core_test_utils::interceptors::ActivationAssertionsInterceptor;
-
-    const SIGNAME: &str = "signame";
-
-    async fn signal_sender(ctx: WfContext) -> WorkflowResult<()> {
-        let mut dat = SignalWorkflowOptions::new("fake_wid", "fake_rid", SIGNAME, [b"hi!"]);
-        dat.with_header("tupac", b"shakur");
-        let res = ctx.signal_workflow(dat).await;
-        if res.is_err() {
-            Err(anyhow::anyhow!("Signal fail!"))
-        } else {
-            Ok(().into())
-        }
-    }
-
-    #[rstest::rstest]
-    #[case::succeeds(false)]
-    #[case::fails(true)]
-    #[tokio::test]
-    async fn sends_signal(#[case] fails: bool) {
-        let mut t = TestHistoryBuilder::default();
-        t.add_by_type(EventType::WorkflowExecutionStarted);
-        t.add_full_wf_task();
-        let id = t.add_signal_wf(SIGNAME, "fake_wid", "fake_rid");
-        if fails {
-            t.add_external_signal_failed(id);
-        } else {
-            t.add_external_signal_completed(id);
-        }
-        t.add_full_wf_task();
-        t.add_workflow_execution_completed();
-
-        let mut mock_cfg = MockPollCfg::from_hist_builder(t);
-        mock_cfg.completion_asserts_from_expectations(|mut asserts| {
-            asserts.then(move |wft| {
-                assert_matches!(wft.commands.as_slice(),
-                    [Command { attributes: Some(
-                        command::Attributes::SignalExternalWorkflowExecutionCommandAttributes(attrs)),..}] => {
-                        assert_eq!(attrs.signal_name, SIGNAME);
-                        assert_eq!(attrs.input.as_ref().unwrap().payloads[0], b"hi!".into());
-                        assert_eq!(*attrs.header.as_ref().unwrap().fields.get("tupac").unwrap(), 
-                                   b"shakur".into());
-                    }
-                );
-            }).then(move |wft| {
-                let cmds = &wft.commands;
-                assert_eq!(cmds.len(), 1);
-                if fails {
-                    assert_eq!(cmds[0].command_type(), CommandType::FailWorkflowExecution);
-                } else {
-                    assert_eq!(
-                        cmds[0].command_type(),
-                        CommandType::CompleteWorkflowExecution
-                    );
-                }
-            });
-        });
-
-        let mut worker = build_fake_sdk(mock_cfg);
-        worker.register_wf(DEFAULT_WORKFLOW_TYPE, signal_sender);
-        worker.run().await.unwrap();
-    }
-
-    #[tokio::test]
-    async fn cancels_before_sending() {
-        let mut t = TestHistoryBuilder::default();
-        t.add_by_type(EventType::WorkflowExecutionStarted);
-        t.add_full_wf_task();
-        t.add_workflow_execution_completed();
-
-        let mut mock_cfg = MockPollCfg::from_hist_builder(t);
-        let mut aai = ActivationAssertionsInterceptor::default();
-        aai.skip_one().then(move |act| {
-            assert_matches!(
-                &act.jobs[0],
-                WorkflowActivationJob {
-                    variant: Some(workflow_activation_job::Variant::ResolveSignalExternalWorkflow(
-                        ResolveSignalExternalWorkflow {
-                            failure: Some(c),
-                            ..
-                        }
-                    ))
-                } => c.message == SIG_CANCEL_MSG
-            );
-        });
-        mock_cfg.completion_asserts_from_expectations(|mut asserts| {
-            asserts.then(move |wft| {
-                assert_eq!(wft.commands.len(), 1);
-                assert_eq!(
-                    wft.commands[0].command_type(),
-                    CommandType::CompleteWorkflowExecution
-                );
-            });
-        });
-
-        let mut worker = build_fake_sdk(mock_cfg);
-        worker.set_worker_interceptor(aai);
-        worker.register_wf(DEFAULT_WORKFLOW_TYPE, |ctx: WfContext| async move {
-            let sig = ctx.signal_workflow(SignalWorkflowOptions::new(
-                "fake_wid",
-                "fake_rid",
-                SIGNAME,
-                [b"hi!"],
-            ));
-            sig.cancel(&ctx);
-            let _res = sig.await;
-            Ok(().into())
-        });
-        worker.run().await.unwrap();
-    }
-
-    #[test]
-    fn cancels_ignored_terminal() {
-        for state in [
-            SignalExternalMachineState::Cancelled(Cancelled {}),
-            Signaled {}.into(),
-        ] {
-            let mut s = SignalExternalMachine::from_parts(state.clone(), Default::default());
-            let cmds = s.cancel().unwrap();
-            assert_eq!(cmds.len(), 0);
-            assert_eq!(discriminant(&state), discriminant(s.state()));
-        }
-    }
-}

package/sdk-core/core/src/worker/workflow/machines/timer_state_machine.rs

@@ -253,125 +253,7 @@ impl WFMachinesAdapter for TimerMachine {
 #[cfg(test)]
 mod test {
     use super::*;
-    use crate::{
-        replay::TestHistoryBuilder,
-        test_help::{MockPollCfg, build_fake_sdk, canned_histories},
-    };
-    use std::{mem::discriminant, time::Duration};
-    use temporal_sdk::{CancellableFuture, WfContext, WorkflowResult};
-    use temporal_sdk_core_protos::{
-        DEFAULT_WORKFLOW_TYPE,
-        temporal::api::{enums::v1::WorkflowTaskFailedCause, failure::v1::Failure},
-    };
-
-    async fn happy_timer(ctx: WfContext) -> WorkflowResult<()> {
-        ctx.timer(Duration::from_secs(5)).await;
-        Ok(().into())
-    }
-
-    #[tokio::test]
-    async fn test_fire_happy_path_inc() {
-        let t = canned_histories::single_timer("1");
-        let mut mock_cfg = MockPollCfg::from_hist_builder(t);
-        mock_cfg.completion_asserts_from_expectations(|mut asserts| {
-            asserts
-                .then(move |wft| {
-                    assert_eq!(wft.commands.len(), 1);
-                    assert_eq!(wft.commands[0].command_type(), CommandType::StartTimer);
-                })
-                .then(move |wft| {
-                    assert_eq!(wft.commands.len(), 1);
-                    assert_eq!(
-                        wft.commands[0].command_type(),
-                        CommandType::CompleteWorkflowExecution
-                    );
-                });
-        });
-
-        let mut worker = build_fake_sdk(mock_cfg);
-        worker.register_wf(DEFAULT_WORKFLOW_TYPE, happy_timer);
-        worker.run().await.unwrap();
-    }
-
-    #[tokio::test]
-    async fn mismatched_timer_ids_errors() {
-        let t = canned_histories::single_timer("badid");
-        let mut mock_cfg = MockPollCfg::from_hist_builder(t);
-        mock_cfg.num_expected_fails = 1;
-        mock_cfg.expect_fail_wft_matcher = Box::new(move |_, cause, f| {
-            matches!(cause, WorkflowTaskFailedCause::NonDeterministicError)
-                && matches!(f, Some(Failure {message, .. })
-            if message.contains("Timer fired event did not have expected timer id 1"))
-        });
-        let mut worker = build_fake_sdk(mock_cfg);
-        worker.register_wf(DEFAULT_WORKFLOW_TYPE, |ctx: WfContext| async move {
-            ctx.timer(Duration::from_secs(5)).await;
-            Ok(().into())
-        });
-        worker.run().await.unwrap();
-    }
-
-    async fn cancel_timer(ctx: WfContext) -> WorkflowResult<()> {
-        let cancel_timer_fut = ctx.timer(Duration::from_secs(500));
-        ctx.timer(Duration::from_secs(5)).await;
-        // Cancel the first timer after having waited on the second
-        cancel_timer_fut.cancel(&ctx);
-        cancel_timer_fut.await;
-        Ok(().into())
-    }
-
-    #[tokio::test]
-    async fn incremental_cancellation() {
-        let t = canned_histories::cancel_timer("2", "1");
-        let mut mock_cfg = MockPollCfg::from_hist_builder(t);
-        mock_cfg.completion_asserts_from_expectations(|mut asserts| {
-            asserts
-                .then(move |wft| {
-                    assert_eq!(wft.commands.len(), 2);
-                    assert_eq!(wft.commands[0].command_type(), CommandType::StartTimer);
-                    assert_eq!(wft.commands[1].command_type(), CommandType::StartTimer);
-                })
-                .then(move |wft| {
-                    assert_eq!(wft.commands.len(), 2);
-                    assert_eq!(wft.commands[0].command_type(), CommandType::CancelTimer);
-                    assert_eq!(
-                        wft.commands[1].command_type(),
-                        CommandType::CompleteWorkflowExecution
-                    );
-                });
-        });
-
-        let mut worker = build_fake_sdk(mock_cfg);
-        worker.register_wf(DEFAULT_WORKFLOW_TYPE, cancel_timer);
-        worker.run().await.unwrap();
-    }
-
-    #[tokio::test]
-    async fn cancel_before_sent_to_server() {
-        let mut t = TestHistoryBuilder::default();
-        t.add_by_type(EventType::WorkflowExecutionStarted);
-        t.add_full_wf_task();
-        t.add_workflow_execution_completed();
-        let mut mock_cfg = MockPollCfg::from_hist_builder(t);
-        mock_cfg.completion_asserts_from_expectations(|mut asserts| {
-            asserts.then(move |wft| {
-                assert_eq!(wft.commands.len(), 1);
-                assert_matches!(
-                    wft.commands[0].command_type(),
-                    CommandType::CompleteWorkflowExecution
-                );
-            });
-        });
-        let mut worker = build_fake_sdk(mock_cfg);
-        worker.register_wf(DEFAULT_WORKFLOW_TYPE, |ctx: WfContext| async move {
-            let cancel_timer_fut = ctx.timer(Duration::from_secs(500));
-            // Immediately cancel the timer
-            cancel_timer_fut.cancel(&ctx);
-            cancel_timer_fut.await;
-            Ok(().into())
-        });
-        worker.run().await.unwrap();
-    }
+    use std::mem::discriminant;
 
     #[test]
     fn cancels_ignored_terminal() {

package/sdk-core/core/src/worker/workflow/machines/upsert_search_attributes_state_machine.rs

@@ -3,14 +3,12 @@ use crate::{
     internal_flags::CoreInternalFlags,
     worker::workflow::{
         InternalFlagsRef, WFMachinesError,
-        machines::{
-            EventInfo, HistEventData, WFMachinesAdapter,
-            patch_state_machine::VERSION_SEARCH_ATTR_KEY,
-        },
+        machines::{EventInfo, HistEventData, WFMachinesAdapter},
     },
 };
 use rustfsm::{StateMachine, TransitionResult, fsm};
 use temporal_sdk_core_protos::{
+    VERSION_SEARCH_ATTR_KEY,
     coresdk::workflow_commands::UpsertWorkflowSearchAttributes,
     temporal::api::{
         command::v1::{UpsertWorkflowSearchAttributesCommandAttributes, command},
@@ -181,18 +179,15 @@ mod tests {
     use super::{super::OnEventWrapper, *};
     use crate::{
         replay::TestHistoryBuilder,
-        test_help::{MockPollCfg, ResponseType, build_fake_sdk, build_mock_pollers, mock_worker},
-        worker::{
-            client::mocks::mock_worker_client,
-            workflow::machines::patch_state_machine::VERSION_SEARCH_ATTR_KEY,
+        test_help::{
+            MockPollCfg, ResponseType, WorkerTestHelpers, build_mock_pollers, mock_worker,
         },
+        worker::client::mocks::mock_worker_client,
     };
     use rustfsm::StateMachine;
     use std::collections::HashMap;
-    use temporal_sdk::WfContext;
     use temporal_sdk_core_api::Worker;
     use temporal_sdk_core_protos::{
-        DEFAULT_WORKFLOW_TYPE,
         coresdk::{
             AsJsonPayloadExt,
             workflow_activation::{WorkflowActivationJob, workflow_activation_job},
@@ -200,64 +195,12 @@ mod tests {
             workflow_completion::WorkflowActivationCompletion,
         },
         temporal::api::{
-            command::v1::{Command, command::Attributes},
+            command::v1::command::Attributes,
             common::v1::Payload,
             enums::v1::EventType,
             history::v1::{HistoryEvent, UpsertWorkflowSearchAttributesEventAttributes},
         },
     };
-    use temporal_sdk_core_test_utils::WorkerTestHelpers;
-
-    #[tokio::test]
-    async fn upsert_search_attrs_from_workflow() {
-        let mut t = TestHistoryBuilder::default();
-        t.add_by_type(EventType::WorkflowExecutionStarted);
-        t.add_full_wf_task();
-        t.add_workflow_execution_completed();
-
-        let (k1, k2) = ("foo", "bar");
-
-        let mut mock_cfg = MockPollCfg::from_hist_builder(t);
-        mock_cfg.completion_asserts_from_expectations(|mut asserts| {
-            asserts.then(|wft| {
-                assert_matches!(
-                    wft.commands.as_slice(),
-                    [Command { attributes: Some(
-                          command::Attributes::UpsertWorkflowSearchAttributesCommandAttributes(msg)
-                        ), .. }, ..] => {
-                        let fields = &msg.search_attributes.as_ref().unwrap().indexed_fields;
-                        let payload1 = fields.get(k1).unwrap();
-                        let payload2 = fields.get(k2).unwrap();
-                        assert_eq!(payload1.data[0], 0x01);
-                        assert_eq!(payload2.data[0], 0x02);
-                        assert_eq!(fields.len(), 2);
-                    }
-                );
-            });
-        });
-
-        let mut worker = build_fake_sdk(mock_cfg);
-        worker.register_wf(DEFAULT_WORKFLOW_TYPE, move |ctx: WfContext| async move {
-            ctx.upsert_search_attributes([
-                (
-                    String::from(k1),
-                    Payload {
-                        data: vec![0x01],
-                        ..Default::default()
-                    },
-                ),
-                (
-                    String::from(k2),
-                    Payload {
-                        data: vec![0x02],
-                        ..Default::default()
-                    },
-                ),
-            ]);
-            Ok(().into())
-        });
-        worker.run().await.unwrap();
-    }
 
     #[rstest::rstest]
     fn upsert_search_attrs_sm() {

package/sdk-core/core/src/worker/workflow/machines/workflow_machines.rs

@@ -32,7 +32,7 @@ use crate::{
                 child_workflow_state_machine::ChildWorkflowMachine,
                 modify_workflow_properties_state_machine::modify_workflow_properties,
                 nexus_operation_state_machine::NexusOperationMachine,
-                patch_state_machine::VERSION_SEARCH_ATTR_KEY, update_state_machine::UpdateMachine,
+                update_state_machine::UpdateMachine,
                 upsert_search_attributes_state_machine::upsert_search_attrs_internal,
             },
         },
@@ -53,11 +53,11 @@ use std::{
 };
 use temporal_sdk_core_api::worker::{WorkerConfig, WorkerDeploymentVersion};
 use temporal_sdk_core_protos::{
+    VERSION_SEARCH_ATTR_KEY,
     coresdk::{
         common::{NamespacedWorkflowExecution, VersioningIntent},
-        workflow_activation,
         workflow_activation::{
-            NotifyHasPatch, UpdateRandomSeed, WorkflowActivation, workflow_activation_job,
+            self, NotifyHasPatch, UpdateRandomSeed, WorkflowActivation, workflow_activation_job,
         },
         workflow_commands::ContinueAsNewWorkflowExecution,
     },
@@ -463,6 +463,11 @@ impl WorkflowMachines {
             continue_as_new_suggested: self.continue_as_new_suggested,
             deployment_version_for_current_task: deployment_version_for_current_task
                 .map(Into::into),
+            last_sdk_version: (*self.observed_internal_flags)
+                .borrow()
+                .last_sdk_version()
+                .unwrap_or_default()
+                .to_owned(),
         }
     }
 
@@ -1352,7 +1357,7 @@ impl WorkflowMachines {
                 WFCommandVariant::AddLocalActivity(attrs) => {
                     let seq = attrs.seq;
                     let attrs: ValidScheduleLA =
-                        ValidScheduleLA::from_schedule_la(attrs).map_err(|e| {
+                        ValidScheduleLA::from_schedule_la(attrs, cmd.metadata).map_err(|e| {
                             WFMachinesError::Fatal(format!(
                                 "Invalid schedule local activity request (seq {seq}): {e}"
                             ))

package/sdk-core/core/src/worker/workflow/mod.rs

@@ -96,7 +96,11 @@ use tokio_stream::wrappers::UnboundedReceiverStream;
 use tokio_util::sync::CancellationToken;
 use tracing::Span;
 
-pub(crate) const LEGACY_QUERY_ID: &str = "legacy_query";
+/// Id used by server for "legacy" queries. IE: Queries that come in the `query` rather than
+/// `queries` field of a WFT, and are responded to on the separate `respond_query_task_completed`
+/// rpc.
+#[allow(unreachable_pub)] // re-exported in supermodule
+pub const LEGACY_QUERY_ID: &str = "legacy_query";
 /// What percentage of a WFT timeout we are willing to wait before sending a WFT heartbeat when
 /// necessary.
 const WFT_HEARTBEAT_TIMEOUT_FRACTION: f32 = 0.8;

package/sdk-core/core/src/worker/workflow/workflow_stream.rs

@@ -578,7 +578,7 @@ impl WFStream {
 #[derive(derive_more::From, Debug)]
 enum WFStreamInput {
     NewWft(Box<PermittedWFT>),
-    Local(LocalInput),
+    Local(Box<LocalInput>),
     /// The stream given to us which represents the poller (or a mock) terminated.
     PollerDead,
     /// The stream given to us which represents the poller (or a mock) encountered a non-retryable
@@ -590,6 +590,11 @@ enum WFStreamInput {
         auto_reply_fail_tt: Option<TaskToken>,
     },
 }
+impl From<LocalInput> for WFStreamInput {
+    fn from(input: LocalInput) -> Self {
+        WFStreamInput::Local(Box::new(input))
+    }
+}
 
 /// A non-poller-received input to the [WFStream]
 #[derive(derive_more::Debug)]
@@ -672,10 +677,10 @@ impl From<ExternalPollerInputs> for WFStreamInput {
                 paginator,
                 update,
                 span,
-            } => WFStreamInput::Local(LocalInput {
+            } => WFStreamInput::Local(Box::new(LocalInput {
                 input: LocalInputs::FetchedPageCompletion { paginator, update },
                 span,
-            }),
+            })),
         }
     }
 }

package/sdk-core/core-api/Cargo.toml

@@ -18,7 +18,7 @@ envconfig = ["dep:toml", "dep:serde", "dep:dirs"]
 
 [dependencies]
 async-trait = "0.1"
-dirs = { version = "5.0", optional = true }
+dirs = { version = "6.0", optional = true }
 derive_builder = { workspace = true }
 derive_more = { workspace = true }
 opentelemetry = { workspace = true, optional = true }
@@ -26,11 +26,11 @@ prost = { workspace = true }
 serde = { version = "1.0", features = ["derive"], optional = true }
 serde_json = "1.0"
 thiserror = { workspace = true }
-toml = { version = "0.8", optional = true }
+toml = { version = "0.9", optional = true }
 tonic = { workspace = true }
 tracing = "0.1"
 tracing-core = "0.1"
-url = "2.3"
+url = "2.5"
 
 [dependencies.temporal-sdk-core-protos]
 path = "../sdk-core-protos"
@@ -40,4 +40,4 @@ version = "0.1"
 workspace = true
 
 [dev-dependencies]
-tempfile = "3.8"
+tempfile = "3.21"