@temporalio/core-bridge 0.16.0 → 0.16.3

package/Cargo.lock

@@ -1550,6 +1550,7 @@ dependencies = [
  "thiserror",
  "tokio",
  "tokio-stream",
+ "tokio-util",
  "tonic 0.6.1",
  "tonic-build 0.6.0",
  "tower",

package/index.d.ts

@@ -125,6 +125,20 @@ export interface WorkerOptions {
    * Maximum number of Workflow instances to cache before automatic eviction
    */
   maxCachedWorkflows: number;
+  /**
+   * Longest interval for throttling activity heartbeats
+   * @default 60 seconds
+   */
+  maxHeartbeatThrottleIntervalMs: number;
+
+  /**
+   * Default interval for throttling activity heartbeats in case
+   * `ActivityOptions.heartbeat_timeout` is unset.
+   * When the timeout *is* set in the `ActivityOptions`, throttling is set to
+   * `heartbeat_timeout * 0.8`.
+   * @default 30 seconds
+   */
+  defaultHeartbeatThrottleIntervalMs: number;
 }
 
 /** Log level - must match rust log level names */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@temporalio/core-bridge",
-  "version": "0.16.0",
+  "version": "0.16.3",
   "description": "Temporal.io SDK Core<>Node bridge",
   "main": "index.node",
   "types": "index.d.ts",
@@ -40,5 +40,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "42638434f033db2b55c43c2a9a7751d883ba17ec"
+  "gitHead": "af54140a4da7e191c06627c5e06b92a3fd929bcc"
 }

package/sdk-core/Cargo.toml

@@ -43,6 +43,7 @@ ringbuf = "0.2"
 slotmap = "1.0"
 thiserror = "1.0"
 tokio = { version = "1.1", features = ["rt", "rt-multi-thread", "parking_lot", "time", "fs"] }
+tokio-util = { version = "0.6.9" }
 tokio-stream = "0.1"
 tonic = { version = "0.6", features = ["tls", "tls-roots"] }
 tower = "0.4"

package/sdk-core/fsm/rustfsm_procmacro/Cargo.toml

@@ -24,4 +24,4 @@ rustfsm_trait = { version = "0.1", path = "../rustfsm_trait" }
 trybuild = { version = "1.0", features = ["diff"] }
 
 [package.metadata.workspaces]
-independent = true
+independent = true

package/sdk-core/fsm/rustfsm_procmacro/src/lib.rs

@@ -1,5 +1,3 @@
-extern crate proc_macro;
-
 use proc_macro::TokenStream;
 use quote::{quote, quote_spanned};
 use std::collections::{hash_map::Entry, HashMap, HashSet};
@@ -82,7 +80,7 @@ use syn::{
 ///                     ReadingCard { card_data: data.clone() }.into(),
 ///                     SharedState { last_id: Some(data) }
 ///                 )
-///             }   
+///             }
 ///         }
 ///     }
 /// }
@@ -200,7 +198,7 @@ impl Parse for StateMachineDefinition {
         // Parse visibility if present
         let visibility = input.parse()?;
         // parse the state machine name, command type, and error type
-        let (name, command_type, error_type, shared_state_type) = parse_machine_types(&input)
+        let (name, command_type, error_type, shared_state_type) = parse_machine_types(input)
             .map_err(|mut e| {
                 e.combine(Error::new(
                     e.span(),
@@ -235,7 +233,7 @@ impl Parse for StateMachineDefinition {
     }
 }
 
-fn parse_machine_types(input: &ParseStream) -> Result<(Ident, Ident, Ident, Option<Type>)> {
+fn parse_machine_types(input: ParseStream) -> Result<(Ident, Ident, Ident, Option<Type>)> {
     let _: kw::name = input.parse()?;
     let name: Ident = input.parse()?;
     input.parse::<Token![;]>()?;
@@ -443,7 +441,7 @@ impl StateMachineDefinition {
                                         },
                             multi_dests => {
                                 let string_dests: Vec<_> = multi_dests.iter()
-                                    .map(|i| i.to_string()).collect();
+                                    .map(ToString::to_string).collect();
                                 let enum_ident = Ident::new(&string_dests.join("Or"),
                                                             multi_dests[0].span());
                                 let multi_dest_enum = quote! {
@@ -558,6 +556,7 @@ impl StateMachineDefinition {
                 fn state(&self) -> &Self::State {
                     &self.state
                 }
+
                 fn set_state(&mut self, new: Self::State) {
                     self.state = new
                 }
@@ -590,7 +589,7 @@ impl StateMachineDefinition {
             #trait_impl
         };
 
-        output.into()
+        TokenStream::from(output)
     }
 
     fn all_states(&self) -> HashSet<Ident> {
@@ -628,7 +627,7 @@ impl StateMachineDefinition {
 /// Merge transition's dest state lists for those with the same from state & handler
 fn merge_transition_dests(transitions: Vec<Transition>) -> Vec<Transition> {
     let mut map = HashMap::<_, Transition>::new();
-    transitions.into_iter().for_each(|t| {
+    for t in transitions {
         // We want to use the transition sans-destinations as the key
         let without_dests = {
             let mut wd = t.clone();
@@ -643,6 +642,6 @@ fn merge_transition_dests(transitions: Vec<Transition>) -> Vec<Transition> {
                 v.insert(t);
             }
         }
-    });
+    }
     map.into_iter().map(|(_, v)| v).collect()
 }

package/sdk-core/fsm/rustfsm_trait/Cargo.toml

@@ -11,4 +11,4 @@ description = "Trait sub-crate of the `rustfsm` crate"
 [dependencies]
 
 [package.metadata.workspaces]
-independent = true
+independent = true

package/sdk-core/fsm/rustfsm_trait/src/lib.rs

@@ -112,7 +112,7 @@ where
     pub fn unwrap(self) -> Vec<M::Command> {
         match self {
             Self::Ok { commands } => commands,
-            _ => panic!("Transition was not successful!"),
+            Self::InvalidTransition => panic!("Transition was not successful!"),
         }
     }
 }

package/sdk-core/sdk-core-protos/src/lib.rs

@@ -38,7 +38,7 @@ pub mod coresdk {
                 activity_id: String,
                 reason: ActivityCancelReason,
             ) -> Self {
-                ActivityTask {
+                Self {
                     task_token,
                     activity_id,
                     variant: Some(activity_task::Variant::Cancel(Cancel {
@@ -75,7 +75,7 @@ pub mod coresdk {
                     })),
                 }
             }
-            pub fn will_complete_async() -> Self {
+            pub const fn will_complete_async() -> Self {
                 Self {
                     status: Some(activity_result::Status::WillCompleteAsync(
                         WillCompleteAsync {},
@@ -195,7 +195,7 @@ pub mod coresdk {
                     "jobs: {})",
                     self.jobs
                         .iter()
-                        .map(|j| j.to_string())
+                        .map(ToString::to_string)
                         .collect::<Vec<_>>()
                         .as_slice()
                         .join(", ")
@@ -264,18 +264,18 @@ pub mod coresdk {
     }
 
     pub mod workflow_completion {
-        use crate::coresdk::workflow_completion::wf_activation_completion::Status;
         tonic::include_proto!("coresdk.workflow_completion");
 
         impl wf_activation_completion::Status {
-            pub fn is_success(&self) -> bool {
+            pub const fn is_success(&self) -> bool {
                 match &self {
-                    Status::Successful(_) => true,
-                    Status::Failed(_) => false,
+                    Self::Successful(_) => true,
+                    Self::Failed(_) => false,
                 }
             }
         }
     }
+
     pub mod child_workflow {
         tonic::include_proto!("coresdk.child_workflow");
     }
@@ -370,7 +370,7 @@ pub mod coresdk {
 
     impl From<wf_activation_job::Variant> for WfActivationJob {
         fn from(a: wf_activation_job::Variant) -> Self {
-            WfActivationJob { variant: Some(a) }
+            Self { variant: Some(a) }
         }
     }
 
@@ -382,7 +382,7 @@ pub mod coresdk {
 
     impl From<workflow_command::Variant> for WorkflowCommand {
         fn from(v: workflow_command::Variant) -> Self {
-            WorkflowCommand { variant: Some(v) }
+            Self { variant: Some(v) }
         }
     }
 
@@ -591,7 +591,7 @@ pub mod coresdk {
     }
 
     impl ActivityResult {
-        pub fn ok(result: Payload) -> Self {
+        pub const fn ok(result: Payload) -> Self {
             Self {
                 status: Some(activity_result::activity_result::Status::Completed(
                     activity_result::Success {
@@ -615,24 +615,18 @@ pub mod coresdk {
                 .workflow_execution
                 .map(|we| (we.workflow_id, we.run_id))
                 .unwrap_or_default();
-            ActivityTask {
+            Self {
                 task_token: r.task_token,
                 activity_id: r.activity_id,
                 variant: Some(activity_task::activity_task::Variant::Start(
                     activity_task::Start {
                         workflow_namespace: r.workflow_namespace,
-                        workflow_type: r
-                            .workflow_type
-                            .map(|wt| wt.name)
-                            .unwrap_or_else(|| "".to_string()),
+                        workflow_type: r.workflow_type.map_or_else(|| "".to_string(), |wt| wt.name),
                         workflow_execution: Some(common::WorkflowExecution {
                             workflow_id,
                             run_id,
                         }),
-                        activity_type: r
-                            .activity_type
-                            .map(|at| at.name)
-                            .unwrap_or_else(|| "".to_string()),
+                        activity_type: r.activity_type.map_or_else(|| "".to_string(), |at| at.name),
                         header_fields: r.header.map(Into::into).unwrap_or_default(),
                         input: Vec::from_payloads(r.input),
                         heartbeat_details: Vec::from_payloads(r.heartbeat_details),
@@ -664,7 +658,7 @@ pub mod coresdk {
 
     impl From<common::WorkflowExecution> for WorkflowExecution {
         fn from(exc: common::WorkflowExecution) -> Self {
-            WorkflowExecution {
+            Self {
                 workflow_id: exc.workflow_id,
                 run_id: exc.run_id,
             }
@@ -767,7 +761,7 @@ pub mod coresdk {
         T: AsRef<[u8]>,
     {
         fn from(v: T) -> Self {
-            Payloads {
+            Self {
                 payloads: vec![v.into()],
             }
         }
@@ -786,10 +780,10 @@ pub mod coresdk {
             match v.payloads.pop() {
                 None => Err(PayloadsToPayloadError::NoPayload),
                 Some(p) => {
-                    if !v.payloads.is_empty() {
-                        Err(PayloadsToPayloadError::MoreThanOnePayload)
-                    } else {
+                    if v.payloads.is_empty() {
                         Ok(p.into())
+                    } else {
+                        Err(PayloadsToPayloadError::MoreThanOnePayload)
                     }
                 }
             }
@@ -1091,26 +1085,22 @@ pub mod temporal {
                 impl HistoryEvent {
                     /// Returns true if this is an event created to mirror a command
                     pub fn is_command_event(&self) -> bool {
-                        if let Some(et) = EventType::from_i32(self.event_type) {
-                            match et {
-                                EventType::ActivityTaskScheduled
-                                | EventType::ActivityTaskCancelRequested
-                                | EventType::MarkerRecorded
-                                | EventType::RequestCancelExternalWorkflowExecutionInitiated
-                                | EventType::SignalExternalWorkflowExecutionInitiated
-                                | EventType::StartChildWorkflowExecutionInitiated
-                                | EventType::TimerCanceled
-                                | EventType::TimerStarted
-                                | EventType::UpsertWorkflowSearchAttributes
-                                | EventType::WorkflowExecutionCanceled
-                                | EventType::WorkflowExecutionCompleted
-                                | EventType::WorkflowExecutionContinuedAsNew
-                                | EventType::WorkflowExecutionFailed => true,
-                                _ => false,
-                            }
-                        } else {
-                            false
-                        }
+                        EventType::from_i32(self.event_type).map_or(false, |et| match et {
+                            EventType::ActivityTaskScheduled
+                            | EventType::ActivityTaskCancelRequested
+                            | EventType::MarkerRecorded
+                            | EventType::RequestCancelExternalWorkflowExecutionInitiated
+                            | EventType::SignalExternalWorkflowExecutionInitiated
+                            | EventType::StartChildWorkflowExecutionInitiated
+                            | EventType::TimerCanceled
+                            | EventType::TimerStarted
+                            | EventType::UpsertWorkflowSearchAttributes
+                            | EventType::WorkflowExecutionCanceled
+                            | EventType::WorkflowExecutionCompleted
+                            | EventType::WorkflowExecutionContinuedAsNew
+                            | EventType::WorkflowExecutionFailed => true,
+                            _ => false,
+                        })
                     }
 
                     /// Returns the command's initiating event id, if present. This is the id of the
@@ -1262,16 +1252,14 @@ pub mod temporal {
                         let last_event = self
                             .history
                             .as_ref()
-                            .map(|h| h.events.last().map(|he| he.event_id))
-                            .flatten()
+                            .and_then(|h| h.events.last().map(|he| he.event_id))
                             .unwrap_or(0);
                         write!(
                             f,
                             "PollWFTQResp(run_id: {}, attempt: {}, last_event: {})",
                             self.workflow_execution
                                 .as_ref()
-                                .map(|we| we.run_id.as_str())
-                                .unwrap_or(""),
+                                .map_or("", |we| we.run_id.as_str()),
                             self.attempt,
                             last_event
                         )

package/sdk-core/src/core_tests/activity_tasks.rs

@@ -76,7 +76,7 @@ async fn max_activities_respected() {
     core.register_worker(
         WorkerConfigBuilder::default()
             .task_queue(TEST_Q)
-            .max_outstanding_activities(2usize)
+            .max_outstanding_activities(2_usize)
             .build()
             .unwrap(),
     )
@@ -163,7 +163,7 @@ async fn heartbeats_report_cancels_only_once() {
     core.record_activity_heartbeat(ActivityHeartbeat {
         task_token: act.task_token.clone(),
         task_queue: TEST_Q.to_string(),
-        details: vec![vec![1u8, 2, 3].into()],
+        details: vec![vec![1_u8, 2, 3].into()],
     });
     // We have to wait a beat for the heartbeat to be processed
     sleep(Duration::from_millis(10)).await;
@@ -183,7 +183,7 @@ async fn heartbeats_report_cancels_only_once() {
     core.record_activity_heartbeat(ActivityHeartbeat {
         task_token: act.task_token,
         task_queue: TEST_Q.to_string(),
-        details: vec![vec![1u8, 2, 3].into()],
+        details: vec![vec![1_u8, 2, 3].into()],
     });
     sleep(Duration::from_millis(10)).await;
     // Since cancels always come before new tasks, if we get a new non-cancel task, we did not
@@ -251,7 +251,7 @@ async fn activity_cancel_interrupts_poll() {
             core.record_activity_heartbeat(ActivityHeartbeat {
                 task_token: act.task_token,
                 task_queue: TEST_Q.to_string(),
-                details: vec![vec![1u8, 2, 3].into()],
+                details: vec![vec![1_u8, 2, 3].into()],
             });
             last_finisher.store(1, Ordering::SeqCst);
         },
@@ -358,7 +358,7 @@ async fn many_concurrent_heartbeat_cancels() {
             .task_queue(TEST_Q)
             .max_outstanding_activities(CONCURRENCY_NUM)
             // Only 1 poll at a time to avoid over-polling and running out of responses
-            .max_concurrent_at_polls(1usize)
+            .max_concurrent_at_polls(1_usize)
             .build()
             .unwrap(),
     )

package/sdk-core/src/core_tests/mod.rs

@@ -91,8 +91,8 @@ async fn shutdown_interrupts_both_polls() {
         WorkerConfigBuilder::default()
             .task_queue(TEST_Q)
             // Need only 1 concurrent pollers for mock expectations to work here
-            .max_concurrent_wft_polls(1usize)
-            .max_concurrent_at_polls(1usize)
+            .max_concurrent_wft_polls(1_usize)
+            .max_concurrent_at_polls(1_usize)
             .build()
             .unwrap(),
     )

package/sdk-core/src/core_tests/workflow_tasks.rs

@@ -642,9 +642,9 @@ async fn workflow_update_random_seed_on_workflow_reset() {
                                 UpdateRandomSeed{randomness_seed})),
                         }] => {
                             assert_ne!(randomness_seed_from_start.load(Ordering::SeqCst),
-                                      *randomness_seed)
+                                      *randomness_seed);
                         }
-                    )
+                    );
                 },
                 vec![CompleteWorkflowExecution { result: None }.into()],
             ),

package/sdk-core/src/errors.rs

@@ -18,7 +18,7 @@ pub(crate) struct WorkflowUpdateError {
 
 impl From<WorkflowMissingError> for WorkflowUpdateError {
     fn from(wme: WorkflowMissingError) -> Self {
-        WorkflowUpdateError {
+        Self {
             source: WFMachinesError::Fatal("Workflow machines missing".to_string()),
             run_id: wme.run_id,
             task_token: None,
@@ -72,8 +72,8 @@ pub enum PollWfError {
 impl From<WorkerLookupErr> for PollWfError {
     fn from(e: WorkerLookupErr) -> Self {
         match e {
-            WorkerLookupErr::Shutdown(_) => PollWfError::ShutDown,
-            WorkerLookupErr::NoWorker(s) => PollWfError::NoWorkerForQueue(s),
+            WorkerLookupErr::Shutdown(_) => Self::ShutDown,
+            WorkerLookupErr::NoWorker(s) => Self::NoWorkerForQueue(s),
         }
     }
 }
@@ -97,8 +97,8 @@ pub enum PollActivityError {
 impl From<WorkerLookupErr> for PollActivityError {
     fn from(e: WorkerLookupErr) -> Self {
         match e {
-            WorkerLookupErr::Shutdown(_) => PollActivityError::ShutDown,
-            WorkerLookupErr::NoWorker(s) => PollActivityError::NoWorkerForQueue(s),
+            WorkerLookupErr::Shutdown(_) => Self::ShutDown,
+            WorkerLookupErr::NoWorker(s) => Self::NoWorkerForQueue(s),
         }
     }
 }
@@ -127,8 +127,9 @@ pub enum CompleteWfError {
 impl From<WorkerLookupErr> for CompleteWfError {
     fn from(e: WorkerLookupErr) -> Self {
         match e {
-            WorkerLookupErr::Shutdown(s) => CompleteWfError::NoWorkerForQueue(s),
-            WorkerLookupErr::NoWorker(s) => CompleteWfError::NoWorkerForQueue(s),
+            WorkerLookupErr::Shutdown(s) | WorkerLookupErr::NoWorker(s) => {
+                Self::NoWorkerForQueue(s)
+            }
         }
     }
 }
@@ -156,8 +157,9 @@ pub enum CompleteActivityError {
 impl From<WorkerLookupErr> for CompleteActivityError {
     fn from(e: WorkerLookupErr) -> Self {
         match e {
-            WorkerLookupErr::Shutdown(s) => CompleteActivityError::NoWorkerForQueue(s),
-            WorkerLookupErr::NoWorker(s) => CompleteActivityError::NoWorkerForQueue(s),
+            WorkerLookupErr::Shutdown(s) | WorkerLookupErr::NoWorker(s) => {
+                Self::NoWorkerForQueue(s)
+            }
         }
     }
 }

package/sdk-core/src/lib.rs

@@ -202,7 +202,7 @@ pub struct CoreInitOptions {
 
 /// Initializes an instance of the core sdk and establishes a connection to the temporal server.
 ///
-/// Note: Also creates a tokio runtime that will be used for all client-server interactions.  
+/// Note: Also creates a tokio runtime that will be used for all client-server interactions.
 ///
 /// # Panics
 /// * Will panic if called from within an async context, as it will construct a runtime and you
@@ -272,7 +272,7 @@ impl Core for CoreSDK {
         }
     }
 
-    #[instrument(level = "debug", skip(self, completion), 
+    #[instrument(level = "debug", skip(self, completion),
       fields(completion=%&completion, run_id=%completion.run_id))]
     async fn complete_workflow_activation(
         &self,

package/sdk-core/src/machines/activity_state_machine.rs

@@ -128,7 +128,7 @@ impl ActivityMachine {
         {
             r.push(MachineResponse::PushWFJob(
                 self.create_cancelation_resolve(None).into(),
-            ))
+            ));
         }
         r
     }
@@ -685,7 +685,7 @@ fn notify_lang_activity_cancelled(
 ) -> ActivityMachineTransition<Canceled> {
     ActivityMachineTransition::ok_shared(
         vec![ActivityMachineCommand::Cancel(
-            canceled_event.map(|e| e.details).flatten(),
+            canceled_event.and_then(|e| e.details),
         )],
         Canceled::default(),
         dat,
@@ -871,7 +871,7 @@ mod test {
             };
             let cmds = s.cancel().unwrap();
             assert_eq!(cmds.len(), 0);
-            assert_eq!(discriminant(&state), discriminant(&s.state))
+            assert_eq!(discriminant(&state), discriminant(&s.state));
         }
     }
 }

package/sdk-core/src/machines/child_workflow_state_machine.rs

@@ -650,11 +650,11 @@ mod test {
     }
 
     impl Expectation {
-        fn try_from_u8(x: u8) -> Option<Self> {
+        const fn try_from_u8(x: u8) -> Option<Self> {
             Some(match x {
-                0 => Expectation::Success,
-                1 => Expectation::Failure,
-                2 => Expectation::StartFailure,
+                0 => Self::Success,
+                1 => Self::Failure,
+                2 => Self::StartFailure,
                 _ => return None,
             })
         }
@@ -820,7 +820,7 @@ mod test {
             };
             let cmds = s.cancel().unwrap();
             assert_eq!(cmds.len(), 0);
-            assert_eq!(discriminant(&state), discriminant(&s.state))
+            assert_eq!(discriminant(&state), discriminant(&s.state));
         }
     }
 }

package/sdk-core/src/machines/complete_workflow_state_machine.rs

@@ -117,7 +117,7 @@ pub(super) struct CompleteWorkflowCommandRecorded {}
 
 impl From<CompleteWorkflowCommandCreated> for CompleteWorkflowCommandRecorded {
     fn from(_: CompleteWorkflowCommandCreated) -> Self {
-        Default::default()
+        Self::default()
     }
 }
 

package/sdk-core/src/machines/continue_as_new_workflow_state_machine.rs

@@ -64,7 +64,7 @@ impl Created {
 
 impl From<ContinueAsNewWorkflowCommandCreated> for ContinueAsNewWorkflowCommandRecorded {
     fn from(_: ContinueAsNewWorkflowCommandCreated) -> Self {
-        Default::default()
+        Self::default()
     }
 }
 

package/sdk-core/src/machines/mod.rs

@@ -77,38 +77,34 @@ impl TryFrom<WorkflowCommand> for WFCommand {
 
     fn try_from(c: WorkflowCommand) -> Result<Self, Self::Error> {
         match c.variant.ok_or(EmptyWorkflowCommandErr)? {
-            workflow_command::Variant::StartTimer(s) => Ok(WFCommand::AddTimer(s)),
-            workflow_command::Variant::CancelTimer(s) => Ok(WFCommand::CancelTimer(s)),
-            workflow_command::Variant::ScheduleActivity(s) => Ok(WFCommand::AddActivity(s)),
+            workflow_command::Variant::StartTimer(s) => Ok(Self::AddTimer(s)),
+            workflow_command::Variant::CancelTimer(s) => Ok(Self::CancelTimer(s)),
+            workflow_command::Variant::ScheduleActivity(s) => Ok(Self::AddActivity(s)),
             workflow_command::Variant::RequestCancelActivity(s) => {
-                Ok(WFCommand::RequestCancelActivity(s))
+                Ok(Self::RequestCancelActivity(s))
             }
             workflow_command::Variant::CompleteWorkflowExecution(c) => {
-                Ok(WFCommand::CompleteWorkflow(c))
+                Ok(Self::CompleteWorkflow(c))
             }
-            workflow_command::Variant::FailWorkflowExecution(s) => Ok(WFCommand::FailWorkflow(s)),
-            workflow_command::Variant::RespondToQuery(s) => Ok(WFCommand::QueryResponse(s)),
+            workflow_command::Variant::FailWorkflowExecution(s) => Ok(Self::FailWorkflow(s)),
+            workflow_command::Variant::RespondToQuery(s) => Ok(Self::QueryResponse(s)),
             workflow_command::Variant::ContinueAsNewWorkflowExecution(s) => {
-                Ok(WFCommand::ContinueAsNew(s))
+                Ok(Self::ContinueAsNew(s))
             }
-            workflow_command::Variant::CancelWorkflowExecution(s) => {
-                Ok(WFCommand::CancelWorkflow(s))
-            }
-            workflow_command::Variant::SetPatchMarker(s) => Ok(WFCommand::SetPatchMarker(s)),
+            workflow_command::Variant::CancelWorkflowExecution(s) => Ok(Self::CancelWorkflow(s)),
+            workflow_command::Variant::SetPatchMarker(s) => Ok(Self::SetPatchMarker(s)),
             workflow_command::Variant::StartChildWorkflowExecution(s) => {
-                Ok(WFCommand::AddChildWorkflow(s))
+                Ok(Self::AddChildWorkflow(s))
             }
             workflow_command::Variant::RequestCancelExternalWorkflowExecution(s) => {
-                Ok(WFCommand::RequestCancelExternalWorkflow(s))
+                Ok(Self::RequestCancelExternalWorkflow(s))
             }
             workflow_command::Variant::SignalExternalWorkflowExecution(s) => {
-                Ok(WFCommand::SignalExternalWorkflow(s))
-            }
-            workflow_command::Variant::CancelSignalWorkflow(s) => {
-                Ok(WFCommand::CancelSignalWorkflow(s))
+                Ok(Self::SignalExternalWorkflow(s))
             }
+            workflow_command::Variant::CancelSignalWorkflow(s) => Ok(Self::CancelSignalWorkflow(s)),
             workflow_command::Variant::CancelUnstartedChildWorkflowExecution(s) => {
-                Ok(WFCommand::CancelUnstartedChild(s))
+                Ok(Self::CancelUnstartedChild(s))
             }
         }
     }
@@ -170,9 +166,7 @@ where
         + Clone
         + Send
         + 'static,
-    <SM as StateMachine>::Event: TryFrom<HistoryEvent>,
-    <SM as StateMachine>::Event: TryFrom<CommandType>,
-    <SM as StateMachine>::Event: Display,
+    <SM as StateMachine>::Event: TryFrom<HistoryEvent> + TryFrom<CommandType> + Display,
     WFMachinesError: From<<<SM as StateMachine>::Event as TryFrom<HistoryEvent>>::Error>,
     <SM as StateMachine>::Command: Debug + Display,
     <SM as StateMachine>::State: Display,