@temporalio/core-bridge 1.5.2 → 1.7.0

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

@@ -2,7 +2,8 @@ use super::{
     workflow_machines::MachineResponse, Cancellable, EventInfo, NewMachineWithCommand,
     OnEventWrapper, WFMachinesAdapter, WFMachinesError,
 };
-use rustfsm::{fsm, TransitionResult};
+use crate::worker::workflow::machines::HistEventData;
+use rustfsm::{fsm, StateMachine, TransitionResult};
 use std::convert::TryFrom;
 use temporal_sdk_core_protos::{
     coresdk::{
@@ -60,10 +61,7 @@ pub(super) fn new_external_cancel(
     only_child: bool,
     reason: String,
 ) -> NewMachineWithCommand {
-    let mut s = CancelExternalMachine {
-        state: Created {}.into(),
-        shared_state: SharedState { seq },
-    };
+    let mut s = CancelExternalMachine::from_parts(Created {}.into(), SharedState { seq });
     OnEventWrapper::on_event_mut(&mut s, CancelExternalMachineEvents::Schedule)
         .expect("Scheduling cancel external wf command doesn't fail");
     let cmd_attrs = command::Attributes::RequestCancelExternalWorkflowExecutionCommandAttributes(
@@ -145,10 +143,11 @@ impl TryFrom<CommandType> for CancelExternalMachineEvents {
     }
 }
 
-impl TryFrom<HistoryEvent> for CancelExternalMachineEvents {
+impl TryFrom<HistEventData> for CancelExternalMachineEvents {
     type Error = WFMachinesError;
 
-    fn try_from(e: HistoryEvent) -> Result<Self, Self::Error> {
+    fn try_from(e: HistEventData) -> Result<Self, Self::Error> {
+        let e = e.event;
         Ok(match e.event_type() {
             EventType::ExternalWorkflowExecutionCancelRequested => {
                 Self::ExternalWorkflowExecutionCancelRequested
@@ -161,15 +160,13 @@ impl TryFrom<HistoryEvent> for CancelExternalMachineEvents {
                     Self::RequestCancelExternalWorkflowExecutionFailed(attrs.cause())
                 } else {
                     return Err(WFMachinesError::Fatal(format!(
-                        "Cancelworkflow failed attributes were unset: {}",
-                        e
+                        "Cancelworkflow failed attributes were unset: {e}"
                     )));
                 }
             }
             _ => {
                 return Err(WFMachinesError::Nondeterminism(format!(
-                    "Cancel external WF machine does not handle this event: {}",
-                    e
+                    "Cancel external WF machine does not handle this event: {e}"
                 )))
             }
         })
@@ -199,7 +196,7 @@ impl WFMachinesAdapter for CancelExternalMachine {
                 vec![ResolveRequestCancelExternalWorkflow {
                     seq: self.shared_state.seq,
                     failure: Some(Failure {
-                        message: format!("Unable to cancel external workflow because {}", reason),
+                        message: format!("Unable to cancel external workflow because {reason}"),
                         failure_info: Some(FailureInfo::ApplicationFailureInfo(
                             ApplicationFailureInfo {
                                 r#type: f.to_string(),

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

@@ -2,7 +2,8 @@ use super::{
     workflow_machines::MachineResponse, Cancellable, EventInfo, HistoryEvent,
     NewMachineWithCommand, OnEventWrapper, WFMachinesAdapter, WFMachinesError,
 };
-use rustfsm::{fsm, TransitionResult};
+use crate::worker::workflow::machines::HistEventData;
+use rustfsm::{fsm, StateMachine, TransitionResult};
 use std::convert::TryFrom;
 use temporal_sdk_core_protos::{
     coresdk::workflow_commands::CancelWorkflowExecution,
@@ -33,10 +34,7 @@ pub(super) enum CancelWorkflowMachineError {}
 pub(super) enum CancelWorkflowCommand {}
 
 pub(super) fn cancel_workflow(attribs: CancelWorkflowExecution) -> NewMachineWithCommand {
-    let mut machine = CancelWorkflowMachine {
-        state: Created {}.into(),
-        shared_state: (),
-    };
+    let mut machine = CancelWorkflowMachine::from_parts(Created {}.into(), ());
     OnEventWrapper::on_event_mut(&mut machine, CancelWorkflowMachineEvents::Schedule)
         .expect("Scheduling continue as new machine doesn't fail");
     let command = Command {
@@ -72,16 +70,16 @@ impl Created {
     }
 }
 
-impl TryFrom<HistoryEvent> for CancelWorkflowMachineEvents {
+impl TryFrom<HistEventData> for CancelWorkflowMachineEvents {
     type Error = WFMachinesError;
 
-    fn try_from(e: HistoryEvent) -> Result<Self, Self::Error> {
+    fn try_from(e: HistEventData) -> Result<Self, Self::Error> {
+        let e = e.event;
         Ok(match EventType::from_i32(e.event_type) {
             Some(EventType::WorkflowExecutionCanceled) => Self::WorkflowExecutionCanceled,
             _ => {
                 return Err(WFMachinesError::Nondeterminism(format!(
-                    "Cancel workflow machine does not handle this event: {}",
-                    e
+                    "Cancel workflow machine does not handle this event: {e}"
                 )))
             }
         })

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

@@ -2,7 +2,11 @@ use super::{
     workflow_machines::MachineResponse, Cancellable, EventInfo, NewMachineWithCommand,
     OnEventWrapper, WFMachinesAdapter, WFMachinesError,
 };
-use rustfsm::{fsm, MachineError, TransitionResult};
+use crate::{
+    internal_flags::CoreInternalFlags,
+    worker::workflow::{machines::HistEventData, InternalFlagsRef},
+};
+use rustfsm::{fsm, MachineError, StateMachine, TransitionResult};
 use std::convert::{TryFrom, TryInto};
 use temporal_sdk_core_protos::{
     coresdk::{
@@ -41,7 +45,7 @@ fsm! {
 
     Created --(Schedule, on_schedule) --> StartCommandCreated;
     StartCommandCreated --(CommandStartChildWorkflowExecution) --> StartCommandCreated;
-    StartCommandCreated --(StartChildWorkflowExecutionInitiated(i64),
+    StartCommandCreated --(StartChildWorkflowExecutionInitiated(ChildWorkflowInitiatedData),
         shared on_start_child_workflow_execution_initiated) --> StartEventRecorded;
     StartCommandCreated --(Cancel, shared on_cancelled) --> Cancelled;
 
@@ -70,6 +74,8 @@ fsm! {
 
     // Ignore any spurious cancellations after resolution
     Cancelled --(Cancel) --> Cancelled;
+    Cancelled --(ChildWorkflowExecutionCancelled,
+        on_child_workflow_execution_cancelled) --> Cancelled;
     Failed --(Cancel) --> Failed;
     StartFailed --(Cancel) --> StartFailed;
     TimedOut --(Cancel) --> TimedOut;
@@ -99,8 +105,38 @@ pub(super) enum ChildWorkflowCommand {
     IssueCancelAfterStarted { reason: String },
 }
 
+pub(super) struct ChildWorkflowInitiatedData {
+    event_id: i64,
+    wf_type: String,
+    wf_id: String,
+    last_task_in_history: bool,
+}
+
 #[derive(Default, Clone)]
-pub(super) struct Cancelled {}
+pub(super) struct Cancelled {
+    seen_cancelled_event: bool,
+}
+
+impl Cancelled {
+    pub(super) fn on_child_workflow_execution_cancelled(
+        self,
+    ) -> ChildWorkflowMachineTransition<Cancelled> {
+        if self.seen_cancelled_event {
+            ChildWorkflowMachineTransition::Err(WFMachinesError::Fatal(
+                "Child workflow has already seen a ChildWorkflowExecutionCanceledEvent, and now \
+                 another is being applied! This is a bug, please report."
+                    .to_string(),
+            ))
+        } else {
+            ChildWorkflowMachineTransition::ok(
+                [],
+                Cancelled {
+                    seen_cancelled_event: true,
+                },
+            )
+        }
+    }
+}
 
 #[derive(Default, Clone)]
 pub(super) struct Completed {}
@@ -123,44 +159,50 @@ pub(super) struct StartCommandCreated {}
 impl StartCommandCreated {
     pub(super) fn on_start_child_workflow_execution_initiated(
         self,
-        state: SharedState,
-        initiated_event_id: i64,
+        state: &mut SharedState,
+        event_dat: ChildWorkflowInitiatedData,
     ) -> ChildWorkflowMachineTransition<StartEventRecorded> {
-        ChildWorkflowMachineTransition::ok_shared(
-            vec![],
-            StartEventRecorded::default(),
-            SharedState {
-                initiated_event_id,
-                ..state
-            },
-        )
+        if state.internal_flags.borrow_mut().try_use(
+            CoreInternalFlags::IdAndTypeDeterminismChecks,
+            event_dat.last_task_in_history,
+        ) {
+            if event_dat.wf_id != state.workflow_id {
+                return TransitionResult::Err(WFMachinesError::Nondeterminism(format!(
+                    "Child workflow id of scheduled event '{}' does not \
+                     match child workflow id of activity command '{}'",
+                    event_dat.wf_id, state.workflow_id
+                )));
+            }
+            if event_dat.wf_type != state.workflow_type {
+                return TransitionResult::Err(WFMachinesError::Nondeterminism(format!(
+                    "Child workflow type of scheduled event '{}' does not \
+                     match child workflow type of activity command '{}'",
+                    event_dat.wf_type, state.workflow_type
+                )));
+            }
+        }
+        state.initiated_event_id = event_dat.event_id;
+        ChildWorkflowMachineTransition::default()
     }
 
     pub(super) fn on_cancelled(
         self,
-        state: SharedState,
+        state: &mut SharedState,
     ) -> ChildWorkflowMachineTransition<Cancelled> {
-        let state = SharedState {
-            cancelled_before_sent: true,
-            ..state
-        };
-        ChildWorkflowMachineTransition::ok_shared(
-            vec![ChildWorkflowCommand::StartCancel(Failure {
-                message: "Child Workflow execution cancelled before scheduled".to_owned(),
-                cause: Some(Box::new(Failure {
-                    failure_info: Some(FailureInfo::CanceledFailureInfo(
-                        failure::CanceledFailureInfo {
-                            ..Default::default()
-                        },
-                    )),
-                    ..Default::default()
-                })),
-                failure_info: failure_info_from_state(&state, RetryState::NonRetryableFailure),
+        state.cancelled_before_sent = true;
+        ChildWorkflowMachineTransition::commands(vec![ChildWorkflowCommand::StartCancel(Failure {
+            message: "Child Workflow execution cancelled before scheduled".to_owned(),
+            cause: Some(Box::new(Failure {
+                failure_info: Some(FailureInfo::CanceledFailureInfo(
+                    failure::CanceledFailureInfo {
+                        ..Default::default()
+                    },
+                )),
                 ..Default::default()
-            })],
-            Cancelled::default(),
-            state,
-        )
+            })),
+            failure_info: failure_info_from_state(state, RetryState::NonRetryableFailure),
+            ..Default::default()
+        })])
     }
 }
 
@@ -170,20 +212,14 @@ pub(super) struct StartEventRecorded {}
 impl StartEventRecorded {
     pub(super) fn on_child_workflow_execution_started(
         self,
-        state: SharedState,
+        state: &mut SharedState,
         event: ChildWorkflowExecutionStartedEvent,
     ) -> ChildWorkflowMachineTransition<Started> {
-        ChildWorkflowMachineTransition::ok_shared(
-            vec![ChildWorkflowCommand::Start(
-                event.workflow_execution.clone(),
-            )],
-            Started::default(),
-            SharedState {
-                started_event_id: event.started_event_id,
-                run_id: event.workflow_execution.run_id,
-                ..state
-            },
-        )
+        state.started_event_id = event.started_event_id;
+        state.run_id = event.workflow_execution.run_id.clone();
+        ChildWorkflowMachineTransition::commands(vec![ChildWorkflowCommand::Start(
+            event.workflow_execution,
+        )])
     }
     pub(super) fn on_start_child_workflow_execution_failed(
         self,
@@ -214,13 +250,13 @@ impl Started {
     }
     fn on_child_workflow_execution_failed(
         self,
-        state: SharedState,
+        state: &mut SharedState,
         attrs: ChildWorkflowExecutionFailedEventAttributes,
     ) -> ChildWorkflowMachineTransition<Failed> {
         ChildWorkflowMachineTransition::ok(
             vec![ChildWorkflowCommand::Fail(Failure {
                 message: "Child Workflow execution failed".to_owned(),
-                failure_info: failure_info_from_state(&state, attrs.retry_state()),
+                failure_info: failure_info_from_state(state, attrs.retry_state()),
                 cause: attrs.failure.map(Box::new),
                 ..Default::default()
             })],
@@ -229,7 +265,7 @@ impl Started {
     }
     fn on_child_workflow_execution_timed_out(
         self,
-        state: SharedState,
+        state: &mut SharedState,
         retry_state: RetryState,
     ) -> ChildWorkflowMachineTransition<TimedOut> {
         ChildWorkflowMachineTransition::ok(
@@ -245,18 +281,23 @@ impl Started {
                     )),
                     ..Default::default()
                 })),
-                failure_info: failure_info_from_state(&state, retry_state),
+                failure_info: failure_info_from_state(state, retry_state),
                 ..Default::default()
             })],
             TimedOut::default(),
         )
     }
     fn on_child_workflow_execution_cancelled(self) -> ChildWorkflowMachineTransition<Cancelled> {
-        ChildWorkflowMachineTransition::ok(vec![ChildWorkflowCommand::Cancel], Cancelled::default())
+        ChildWorkflowMachineTransition::ok(
+            vec![ChildWorkflowCommand::Cancel],
+            Cancelled {
+                seen_cancelled_event: true,
+            },
+        )
     }
     fn on_child_workflow_execution_terminated(
         self,
-        state: SharedState,
+        state: &mut SharedState,
     ) -> ChildWorkflowMachineTransition<Terminated> {
         ChildWorkflowMachineTransition::ok(
             vec![ChildWorkflowCommand::Fail(Failure {
@@ -268,7 +309,7 @@ impl Started {
                     )),
                     ..Default::default()
                 })),
-                failure_info: failure_info_from_state(&state, RetryState::NonRetryableFailure),
+                failure_info: failure_info_from_state(state, RetryState::NonRetryableFailure),
                 ..Default::default()
             })],
             Terminated::default(),
@@ -276,7 +317,7 @@ impl Started {
     }
     fn on_cancelled(
         self,
-        state: SharedState,
+        state: &mut SharedState,
     ) -> ChildWorkflowMachineTransition<StartedOrCancelled> {
         let dest = match state.cancel_type {
             ChildWorkflowCancellationType::Abandon | ChildWorkflowCancellationType::TryCancel => {
@@ -299,7 +340,7 @@ pub(super) struct Terminated {}
 #[derive(Default, Clone)]
 pub(super) struct TimedOut {}
 
-#[derive(Default, Clone, Debug)]
+#[derive(Clone, Debug)]
 pub(super) struct SharedState {
     initiated_event_id: i64,
     started_event_id: i64,
@@ -310,38 +351,40 @@ pub(super) struct SharedState {
     workflow_type: String,
     cancelled_before_sent: bool,
     cancel_type: ChildWorkflowCancellationType,
-}
-
-/// Creates a new child workflow state machine and a command to start it on the server.
-pub(super) fn new_child_workflow(attribs: StartChildWorkflowExecution) -> NewMachineWithCommand {
-    let (wf, add_cmd) = ChildWorkflowMachine::new_scheduled(attribs);
-    NewMachineWithCommand {
-        command: add_cmd,
-        machine: wf.into(),
-    }
+    internal_flags: InternalFlagsRef,
 }
 
 impl ChildWorkflowMachine {
     /// Create a new child workflow and immediately schedule it.
-    pub(crate) fn new_scheduled(attribs: StartChildWorkflowExecution) -> (Self, Command) {
-        let mut s = Self {
-            state: Created {}.into(),
-            shared_state: SharedState {
+    pub(super) fn new_scheduled(
+        attribs: StartChildWorkflowExecution,
+        internal_flags: InternalFlagsRef,
+    ) -> NewMachineWithCommand {
+        let mut s = Self::from_parts(
+            Created {}.into(),
+            SharedState {
                 lang_sequence_number: attribs.seq,
                 workflow_id: attribs.workflow_id.clone(),
                 workflow_type: attribs.workflow_type.clone(),
                 namespace: attribs.namespace.clone(),
                 cancel_type: attribs.cancellation_type(),
-                ..Default::default()
+                internal_flags,
+                run_id: "".to_string(),
+                initiated_event_id: 0,
+                started_event_id: 0,
+                cancelled_before_sent: false,
             },
-        };
+        );
         OnEventWrapper::on_event_mut(&mut s, ChildWorkflowMachineEvents::Schedule)
             .expect("Scheduling child workflows doesn't fail");
         let cmd = Command {
             command_type: CommandType::StartChildWorkflowExecution as i32,
             attributes: Some(attribs.into()),
         };
-        (s, cmd)
+        NewMachineWithCommand {
+            command: cmd,
+            machine: s.into(),
+        }
     }
 
     fn resolve_cancelled_msg(&self) -> ResolveChildWorkflowExecution {
@@ -372,13 +415,31 @@ impl ChildWorkflowMachine {
     }
 }
 
-impl TryFrom<HistoryEvent> for ChildWorkflowMachineEvents {
+impl TryFrom<HistEventData> for ChildWorkflowMachineEvents {
     type Error = WFMachinesError;
 
-    fn try_from(e: HistoryEvent) -> Result<Self, Self::Error> {
+    fn try_from(e: HistEventData) -> Result<Self, Self::Error> {
+        let last_task_in_history = e.current_task_is_last_in_history;
+        let e = e.event;
         Ok(match EventType::from_i32(e.event_type) {
             Some(EventType::StartChildWorkflowExecutionInitiated) => {
-                Self::StartChildWorkflowExecutionInitiated(e.event_id)
+                if let Some(
+                    history_event::Attributes::StartChildWorkflowExecutionInitiatedEventAttributes(
+                        attrs,
+                    ),
+                ) = e.attributes
+                {
+                    Self::StartChildWorkflowExecutionInitiated(ChildWorkflowInitiatedData {
+                        event_id: e.event_id,
+                        wf_type: attrs.workflow_type.unwrap_or_default().name,
+                        wf_id: attrs.workflow_id,
+                        last_task_in_history,
+                    })
+                } else {
+                    return Err(WFMachinesError::Fatal(
+                        "StartChildWorkflowExecutionInitiated attributes were unset".to_string(),
+                    ));
+                }
             }
             Some(EventType::StartChildWorkflowExecutionFailed) => {
                 if let Some(
@@ -471,8 +532,7 @@ impl TryFrom<HistoryEvent> for ChildWorkflowMachineEvents {
             }
             _ => {
                 return Err(WFMachinesError::Fatal(format!(
-                    "Child workflow machine does not handle this event: {:?}",
-                    e
+                    "Child workflow machine does not handle this event: {e:?}"
                 )))
             }
         })
@@ -612,7 +672,7 @@ impl Cancellable for ChildWorkflowMachine {
                 | c @ ChildWorkflowCommand::IssueCancelAfterStarted { .. } => {
                     self.adapt_response(c, None)
                 }
-                x => panic!("Invalid cancel event response {:?}", x),
+                x => panic!("Invalid cancel event response {x:?}"),
             })
             .collect::<Result<Vec<_>, _>>()?
             .into_iter()
@@ -650,8 +710,7 @@ fn convert_payloads(
 ) -> Result<Option<Payload>, WFMachinesError> {
     result.map(TryInto::try_into).transpose().map_err(|pe| {
         WFMachinesError::Fatal(format!(
-            "Not exactly one payload in child workflow result ({}) for event: {:?}",
-            pe, event_info
+            "Not exactly one payload in child workflow result ({pe}) for event: {event_info:?}"
         ))
     })
 }
@@ -660,11 +719,12 @@ fn convert_payloads(
 mod test {
     use super::*;
     use crate::{
-        replay::TestHistoryBuilder, test_help::canned_histories, worker::workflow::ManagedWFFunc,
+        internal_flags::InternalFlags, replay::TestHistoryBuilder, test_help::canned_histories,
+        worker::workflow::ManagedWFFunc,
     };
     use anyhow::anyhow;
     use rstest::{fixture, rstest};
-    use std::mem::discriminant;
+    use std::{cell::RefCell, mem::discriminant, rc::Rc};
     use temporal_sdk::{
         CancellableFuture, ChildWorkflowOptions, WfContext, WorkflowFunction, WorkflowResult,
     };
@@ -840,19 +900,32 @@ mod test {
     #[test]
     fn cancels_ignored_terminal() {
         for state in [
-            ChildWorkflowMachineState::Cancelled(Cancelled {}),
+            ChildWorkflowMachineState::Cancelled(Cancelled {
+                seen_cancelled_event: false,
+            }),
             Failed {}.into(),
             StartFailed {}.into(),
             TimedOut {}.into(),
             Completed {}.into(),
         ] {
-            let mut s = ChildWorkflowMachine {
-                state: state.clone(),
-                shared_state: Default::default(),
-            };
+            let mut s = ChildWorkflowMachine::from_parts(
+                state.clone(),
+                SharedState {
+                    initiated_event_id: 0,
+                    started_event_id: 0,
+                    lang_sequence_number: 0,
+                    namespace: "".to_string(),
+                    workflow_id: "".to_string(),
+                    run_id: "".to_string(),
+                    workflow_type: "".to_string(),
+                    cancelled_before_sent: false,
+                    cancel_type: Default::default(),
+                    internal_flags: Rc::new(RefCell::new(InternalFlags::new(&Default::default()))),
+                },
+            );
             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/core/src/worker/workflow/machines/complete_workflow_state_machine.rs

@@ -2,7 +2,8 @@ use super::{
     workflow_machines::MachineResponse, Cancellable, EventInfo, NewMachineWithCommand,
     OnEventWrapper, WFMachinesAdapter, WFMachinesError,
 };
-use rustfsm::{fsm, TransitionResult};
+use crate::worker::workflow::machines::HistEventData;
+use rustfsm::{fsm, StateMachine, TransitionResult};
 use std::convert::TryFrom;
 use temporal_sdk_core_protos::{
     coresdk::workflow_commands::CompleteWorkflowExecution,
@@ -18,9 +19,9 @@ fsm! {
     name CompleteWorkflowMachine;
     command CompleteWFCommand;
     error WFMachinesError;
-    shared_state CompleteWorkflowExecution;
+    shared_state ();
 
-    Created --(Schedule, shared on_schedule) --> CompleteWorkflowCommandCreated;
+    Created --(Schedule, on_schedule) --> CompleteWorkflowCommandCreated;
 
     CompleteWorkflowCommandCreated --(CommandCompleteWorkflowExecution)
         --> CompleteWorkflowCommandCreated;
@@ -45,10 +46,7 @@ pub(super) fn complete_workflow(attribs: CompleteWorkflowExecution) -> NewMachin
 impl CompleteWorkflowMachine {
     /// Create a new WF machine and schedule it
     pub(crate) fn new_scheduled(attribs: CompleteWorkflowExecution) -> (Self, Command) {
-        let mut s = Self {
-            state: Created {}.into(),
-            shared_state: attribs,
-        };
+        let mut s = Self::from_parts(Created { attribs }.into(), ());
         let cmd =
             match OnEventWrapper::on_event_mut(&mut s, CompleteWorkflowMachineEvents::Schedule)
                 .expect("Scheduling complete wf machines doesn't fail")
@@ -61,16 +59,16 @@ impl CompleteWorkflowMachine {
     }
 }
 
-impl TryFrom<HistoryEvent> for CompleteWorkflowMachineEvents {
+impl TryFrom<HistEventData> for CompleteWorkflowMachineEvents {
     type Error = WFMachinesError;
 
-    fn try_from(e: HistoryEvent) -> Result<Self, Self::Error> {
+    fn try_from(e: HistEventData) -> Result<Self, Self::Error> {
+        let e = e.event;
         Ok(match e.event_type() {
             EventType::WorkflowExecutionCompleted => Self::WorkflowExecutionCompleted,
             _ => {
                 return Err(WFMachinesError::Nondeterminism(format!(
-                    "Complete workflow machine does not handle this event: {}",
-                    e
+                    "Complete workflow machine does not handle this event: {e}"
                 )))
             }
         })
@@ -89,16 +87,17 @@ impl TryFrom<CommandType> for CompleteWorkflowMachineEvents {
 }
 
 #[derive(Default, Clone)]
-pub(super) struct Created {}
+pub(super) struct Created {
+    attribs: CompleteWorkflowExecution,
+}
 
 impl Created {
     pub(super) fn on_schedule(
         self,
-        dat: CompleteWorkflowExecution,
     ) -> CompleteWorkflowMachineTransition<CompleteWorkflowCommandCreated> {
         let cmd = Command {
             command_type: CommandType::CompleteWorkflowExecution as i32,
-            attributes: Some(dat.into()),
+            attributes: Some(self.attribs.into()),
         };
         TransitionResult::commands(vec![CompleteWFCommand::AddCommand(cmd)])
     }

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

@@ -2,7 +2,8 @@ use super::{
     Cancellable, EventInfo, HistoryEvent, MachineResponse, NewMachineWithCommand, OnEventWrapper,
     WFMachinesAdapter, WFMachinesError,
 };
-use rustfsm::{fsm, TransitionResult};
+use crate::worker::workflow::machines::HistEventData;
+use rustfsm::{fsm, StateMachine, TransitionResult};
 use std::convert::TryFrom;
 use temporal_sdk_core_protos::{
     coresdk::workflow_commands::ContinueAsNewWorkflowExecution,
@@ -30,10 +31,7 @@ fsm! {
 pub(super) enum ContinueAsNewWorkflowCommand {}
 
 pub(super) fn continue_as_new(attribs: ContinueAsNewWorkflowExecution) -> NewMachineWithCommand {
-    let mut machine = ContinueAsNewWorkflowMachine {
-        state: Created {}.into(),
-        shared_state: (),
-    };
+    let mut machine = ContinueAsNewWorkflowMachine::from_parts(Created {}.into(), ());
     OnEventWrapper::on_event_mut(&mut machine, ContinueAsNewWorkflowMachineEvents::Schedule)
         .expect("Scheduling continue as new machine doesn't fail");
     let command = Command {
@@ -69,16 +67,16 @@ impl From<ContinueAsNewWorkflowCommandCreated> for ContinueAsNewWorkflowCommandR
     }
 }
 
-impl TryFrom<HistoryEvent> for ContinueAsNewWorkflowMachineEvents {
+impl TryFrom<HistEventData> for ContinueAsNewWorkflowMachineEvents {
     type Error = WFMachinesError;
 
-    fn try_from(e: HistoryEvent) -> Result<Self, Self::Error> {
+    fn try_from(e: HistEventData) -> Result<Self, Self::Error> {
+        let e = e.event;
         Ok(match e.event_type() {
             EventType::WorkflowExecutionContinuedAsNew => Self::WorkflowExecutionContinuedAsNew,
             _ => {
                 return Err(WFMachinesError::Nondeterminism(format!(
-                    "Continue as new workflow machine does not handle this event: {}",
-                    e
+                    "Continue as new workflow machine does not handle this event: {e}"
                 )))
             }
         })