@temporalio/core-bridge 0.16.0 → 0.16.3

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

@@ -107,7 +107,7 @@ impl PatchMachine {
                 .into(),
             ),
         };
-        let mut machine = PatchMachine {
+        let mut machine = Self {
             state: initial_state,
             shared_state: state,
         };
@@ -210,7 +210,7 @@ impl TryFrom<HistoryEvent> for PatchMachineEvents {
 
     fn try_from(e: HistoryEvent) -> Result<Self, Self::Error> {
         match e.get_changed_marker_details() {
-            Some((id, _)) => Ok(PatchMachineEvents::MarkerRecorded(id)),
+            Some((id, _)) => Ok(Self::MarkerRecorded(id)),
             _ => Err(WFMachinesError::Nondeterminism(format!(
                 "Change machine cannot handle this event: {}",
                 e
@@ -422,7 +422,9 @@ mod tests {
             commands[0].command_type,
             CommandType::ScheduleActivityTask as i32
         );
-        let act = if !replaying {
+        let act = if replaying {
+            wfm.get_next_activation().await
+        } else {
             // Feed more history
             wfm.new_history(
                 patch_marker_single_activity(marker_type)
@@ -431,8 +433,6 @@ mod tests {
                     .into(),
             )
             .await
-        } else {
-            wfm.get_next_activation().await
         };
 
         if marker_type == MarkerType::Deprecated {
@@ -514,7 +514,9 @@ mod tests {
             if activity_id == expected_activity_id
         );
 
-        let act = if !replaying {
+        let act = if replaying {
+            wfm.get_next_activation().await
+        } else {
             // Feed more history. Since we are *not* replaying, we *always* "have" the change
             // and the history should have the has-change timer. v3 of course always has the change
             // regardless.
@@ -525,8 +527,6 @@ mod tests {
                     .into(),
             )
             .await
-        } else {
-            wfm.get_next_activation().await
         };
 
         let act = act.unwrap();

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

@@ -266,7 +266,7 @@ impl Cancellable for SignalExternalMachine {
                         ..Default::default()
                     }),
                 }
-                .into()]
+                .into()];
             }
             Some(_) => panic!("Signal external machine cancel produced unexpected result"),
             None => (),
@@ -400,7 +400,7 @@ mod tests {
             };
             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/timer_state_machine.rs

@@ -199,13 +199,13 @@ impl StartCommandRecorded {
         dat: SharedState,
         attrs: TimerFiredEventAttributes,
     ) -> TimerMachineTransition<Fired> {
-        if dat.attrs.seq.to_string() != attrs.timer_id {
+        if dat.attrs.seq.to_string() == attrs.timer_id {
+            TransitionResult::ok(vec![TimerMachineCommand::Complete], Fired::default())
+        } else {
             TransitionResult::Err(WFMachinesError::Fatal(format!(
                 "Timer fired event did not have expected timer id {}, it was {}!",
                 dat.attrs.seq, attrs.timer_id
             )))
-        } else {
-            TransitionResult::ok(vec![TimerMachineCommand::Complete], Fired::default())
         }
     }
 
@@ -435,7 +435,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/transition_coverage.rs

@@ -79,7 +79,7 @@ mod machine_coverage_report {
         workflow_task_state_machine::WorkflowTaskMachine,
     };
     use rustfsm::StateMachine;
-    use std::{fs::File, io::Write, ops::Deref};
+    use std::{fs::File, io::Write};
 
     // This "test" needs to exist so that we have a way to join the spawned thread. Otherwise
     // it'll just get abandoned.
@@ -89,7 +89,7 @@ mod machine_coverage_report {
     #[ignore]
     fn reporter() {
         // Make sure thread handle exists
-        let _ = COVERAGE_SENDER.deref();
+        let _ = &*COVERAGE_SENDER;
         // Join it
         THREAD_HANDLE
             .lock()
@@ -124,7 +124,7 @@ mod machine_coverage_report {
                 m @ "WorkflowTaskMachine" => cover_transitions(m, &mut wf_task, coverage),
                 m @ "FailWorkflowMachine" => cover_transitions(m, &mut fail_wf, coverage),
                 m @ "ContinueAsNewWorkflowMachine" => {
-                    cover_transitions(m, &mut cont_as_new, coverage)
+                    cover_transitions(m, &mut cont_as_new, coverage);
                 }
                 m @ "CancelWorkflowMachine" => cover_transitions(m, &mut cancel_wf, coverage),
                 m @ "PatchMachine" => cover_transitions(m, &mut version, coverage),

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

@@ -150,7 +150,7 @@ where
     T: Into<wf_activation_job::Variant>,
 {
     fn from(v: T) -> Self {
-        MachineResponse::PushWFJob(v.into())
+        Self::PushWFJob(v.into())
     }
 }
 
@@ -171,7 +171,7 @@ pub(crate) enum WFMachinesError {
 
 impl From<TimestampOutOfSystemRangeError> for WFMachinesError {
     fn from(_: TimestampOutOfSystemRangeError) -> Self {
-        WFMachinesError::Fatal("Could not decode timestamp".to_string())
+        Self::Fatal("Could not decode timestamp".to_string())
     }
 }
 
@@ -210,7 +210,7 @@ impl WorkflowMachines {
     }
 
     /// Returns true if workflow has seen a terminal command
-    pub(crate) fn workflow_is_finished(&self) -> bool {
+    pub(crate) const fn workflow_is_finished(&self) -> bool {
         self.workflow_end_time.is_some()
     }
 
@@ -486,7 +486,7 @@ impl WorkflowMachines {
     }
 
     fn set_current_time(&mut self, time: SystemTime) -> SystemTime {
-        if self.current_wf_time.map(|t| t < time).unwrap_or(true) {
+        if self.current_wf_time.map_or(true, |t| t < time) {
             self.current_wf_time = Some(time);
         }
         self.current_wf_time
@@ -503,7 +503,7 @@ impl WorkflowMachines {
         let results = self.drive_me.fetch_workflow_iteration_output().await;
         let jobs = self.handle_driven_results(results)?;
         let has_new_lang_jobs = !jobs.is_empty();
-        for job in jobs.into_iter() {
+        for job in jobs {
             self.drive_me.send_job(job);
         }
         self.prepare_commands()?;
@@ -695,7 +695,7 @@ impl WorkflowMachines {
                     self.current_wf_task_commands.push_back(timer);
                 }
                 WFCommand::CancelTimer(attrs) => {
-                    jobs.extend(self.process_cancellation(CommandID::Timer(attrs.seq))?)
+                    jobs.extend(self.process_cancellation(CommandID::Timer(attrs.seq))?);
                 }
                 WFCommand::AddActivity(attrs) => {
                     let seq = attrs.seq;
@@ -705,7 +705,7 @@ impl WorkflowMachines {
                     self.current_wf_task_commands.push_back(activity);
                 }
                 WFCommand::RequestCancelActivity(attrs) => {
-                    jobs.extend(self.process_cancellation(CommandID::Activity(attrs.seq))?)
+                    jobs.extend(self.process_cancellation(CommandID::Activity(attrs.seq))?);
                 }
                 WFCommand::CompleteWorkflow(attrs) => {
                     self.metrics.wf_completed();
@@ -815,7 +815,7 @@ impl WorkflowMachines {
                     self.current_wf_task_commands.push_back(sigm);
                 }
                 WFCommand::CancelSignalWorkflow(attrs) => {
-                    jobs.extend(self.process_cancellation(CommandID::SignalExternal(attrs.seq))?)
+                    jobs.extend(self.process_cancellation(CommandID::SignalExternal(attrs.seq))?);
                 }
                 WFCommand::QueryResponse(_) => {
                     // Nothing to do here, queries are handled above the machine level
@@ -840,7 +840,7 @@ impl WorkflowMachines {
                     self.current_wf_task_commands.push_back(CommandAndMachine {
                         command: c,
                         machine: m_key,
-                    })
+                    });
                 }
                 MachineResponse::PushWFJob(j) => {
                     jobs.push(j);

package/sdk-core/src/pending_activations.rs

@@ -68,15 +68,14 @@ impl PendingActivations {
         let mut inner = self.inner.write();
         let mut key_queue = inner.queue.iter().copied();
         let maybe_key = key_queue.position(|k| {
-            if let Some(activation) = inner.activations.get(k) {
-                predicate(&activation.run_id)
-            } else {
-                false
-            }
+            inner
+                .activations
+                .get(k)
+                .map_or(false, |activation| predicate(&activation.run_id))
         });
 
         let maybe_key = maybe_key.map(|pos| inner.queue.remove(pos).unwrap());
-        if let Some(key) = maybe_key {
+        maybe_key.and_then(|key| {
             if let Some(pa) = inner.activations.remove(key) {
                 inner.by_run_id.remove(&pa.run_id);
                 Some(pa)
@@ -87,9 +86,7 @@ impl PendingActivations {
                 drop(inner); // Will deadlock when we recurse w/o this
                 self.pop()
             }
-        } else {
-            None
-        }
+        })
     }
 
     pub fn pop(&self) -> Option<WfActivation> {
@@ -119,17 +116,19 @@ fn merge_joblists(
         .as_mut_slice()
         .sort_by(evictions_always_last_compare);
     // Drop any duplicate evictions
-    let truncate_len = if let Some(last_non_evict_job) = existing_list.iter().rev().position(|j| {
-        !matches!(
-            j.variant,
-            Some(wf_activation_job::Variant::RemoveFromCache(_))
-        )
-    }) {
-        existing_list.len() - last_non_evict_job + 1
-    } else {
-        1
-    };
-    existing_list.truncate(truncate_len)
+    let truncate_len = existing_list
+        .iter()
+        .rev()
+        .position(|j| {
+            !matches!(
+                j.variant,
+                Some(wf_activation_job::Variant::RemoveFromCache(_))
+            )
+        })
+        .map_or(1, |last_non_evict_job| {
+            existing_list.len() - last_non_evict_job + 1
+        });
+    existing_list.truncate(truncate_len);
 }
 
 fn evictions_always_last_compare(a: &WfActivationJob, b: &WfActivationJob) -> Ordering {

package/sdk-core/src/pollers/gateway.rs

@@ -165,7 +165,7 @@ impl Default for RetryConfig {
 }
 
 impl RetryConfig {
-    pub(crate) fn poll_retry_policy() -> Self {
+    pub(crate) const fn poll_retry_policy() -> Self {
         Self {
             initial_interval: Duration::from_millis(200),
             randomization_factor: 0.2,
@@ -179,7 +179,7 @@ impl RetryConfig {
 
 impl From<RetryConfig> for ExponentialBackoff {
     fn from(c: RetryConfig) -> Self {
-        ExponentialBackoff {
+        Self {
             current_interval: c.initial_interval,
             initial_interval: c.initial_interval,
             randomization_factor: c.randomization_factor,
@@ -269,7 +269,7 @@ impl Interceptor for ServiceCallInterceptor {
                 .parse()
                 .unwrap_or_else(|_| MetadataValue::from_static("")),
         );
-        for (k, v) in self.opts.static_headers.iter() {
+        for (k, v) in &self.opts.static_headers {
             if let (Ok(k), Ok(v)) = (MetadataKey::from_str(k), MetadataValue::from_str(v)) {
                 metadata.insert(k, v);
             }

package/sdk-core/src/pollers/poll_buffer.rs

@@ -152,7 +152,7 @@ where
 
     async fn shutdown_box(self: Box<Self>) {
         let this = *self;
-        this.shutdown().await
+        this.shutdown().await;
     }
 }
 
@@ -192,7 +192,7 @@ impl Poller<PollWorkflowTaskQueueResponse> for WorkflowTaskPoller {
 
     async fn shutdown_box(self: Box<Self>) {
         let this = *self;
-        this.shutdown().await
+        this.shutdown().await;
     }
 }
 

package/sdk-core/src/pollers/retry.rs

@@ -27,7 +27,7 @@ pub struct RetryGateway<SG> {
 
 impl<SG> RetryGateway<SG> {
     /// Use the provided retry config with the provided gateway
-    pub fn new(gateway: SG, retry_config: RetryConfig) -> Self {
+    pub const fn new(gateway: SG, retry_config: RetryConfig) -> Self {
         Self {
             gateway,
             retry_config,
@@ -76,7 +76,7 @@ impl TonicErrorHandler {
         }
     }
 
-    fn should_log_retry_warning(&self, cur_attempt: usize) -> bool {
+    const fn should_log_retry_warning(&self, cur_attempt: usize) -> bool {
         // Warn on more than 5 retries for unlimited retrying
         if self.max_retries == 0 && cur_attempt > 5 {
             return true;
@@ -104,9 +104,9 @@ impl ErrorHandler<tonic::Status> for TonicErrorHandler {
         }
 
         if current_attempt == 1 {
-            debug!(error=?e, "gRPC call {} failed on first attempt", self.call_name)
+            debug!(error=?e, "gRPC call {} failed on first attempt", self.call_name);
         } else if self.should_log_retry_warning(current_attempt) {
-            warn!(error=?e, "gRPC call {} retried {} times", self.call_name, current_attempt)
+            warn!(error=?e, "gRPC call {} retried {} times", self.call_name, current_attempt);
         }
 
         // Long polls are OK with being cancelled or running into the timeout because there's

package/sdk-core/src/prototype_rust_sdk/workflow_context.rs

@@ -99,7 +99,7 @@ impl WfContext {
         self.am_cancelled
             .changed()
             .await
-            .expect("Cancelled send half not dropped")
+            .expect("Cancelled send half not dropped");
     }
 
     /// Request to create a timer
@@ -206,7 +206,7 @@ impl WfContext {
 
     /// Force a workflow task failure (EX: in order to retry on non-sticky queue)
     pub fn force_task_fail(&self, with: anyhow::Error) {
-        self.send(with.into())
+        self.send(with.into());
     }
 
     /// Request the cancellation of an external workflow. May resolve as a failure if the workflow
@@ -262,7 +262,7 @@ impl WfContext {
 
     /// Cancel any cancellable operation by ID
     fn cancel(&mut self, cancellable_id: CancellableID) {
-        self.send(RustWfCmd::Cancel(cancellable_id))
+        self.send(RustWfCmd::Cancel(cancellable_id));
     }
 
     fn send(&self, c: RustWfCmd) {

package/sdk-core/src/prototype_rust_sdk/workflow_future.rs

@@ -169,7 +169,7 @@ impl WorkflowFuture {
                     self.unblock(UnblockEvent::Activity(
                         seq,
                         Box::new(result.context("Activity must have result")?),
-                    ))?
+                    ))?;
                 }
                 Variant::ResolveChildWorkflowExecutionStart(
                     ResolveChildWorkflowExecutionStart { seq, status },
@@ -184,7 +184,7 @@ impl WorkflowFuture {
                     seq,
                     Box::new(result.context("Child Workflow execution must have a result")?),
                 ))?,
-                Variant::UpdateRandomSeed(_) => {}
+                Variant::UpdateRandomSeed(_) => (),
                 Variant::QueryWorkflow(_) => {
                     todo!()
                 }
@@ -209,10 +209,10 @@ impl WorkflowFuture {
                     self.ctx_shared.write().changes.insert(patch_id, true);
                 }
                 Variant::ResolveSignalExternalWorkflow(attrs) => {
-                    self.unblock(UnblockEvent::SignalExternal(attrs.seq, attrs.failure))?
+                    self.unblock(UnblockEvent::SignalExternal(attrs.seq, attrs.failure))?;
                 }
                 Variant::ResolveRequestCancelExternalWorkflow(attrs) => {
-                    self.unblock(UnblockEvent::CancelExternal(attrs.seq, attrs.failure))?
+                    self.unblock(UnblockEvent::CancelExternal(attrs.seq, attrs.failure))?;
                 }
 
                 Variant::RemoveFromCache(_) => {

package/sdk-core/src/prototype_rust_sdk.rs

@@ -250,7 +250,7 @@ impl Unblockable for PendingChildWorkflow {
     type OtherDat = ChildWfCommon;
     fn unblock(ue: UnblockEvent, od: Self::OtherDat) -> Self {
         match ue {
-            UnblockEvent::WorkflowStart(_, result) => PendingChildWorkflow {
+            UnblockEvent::WorkflowStart(_, result) => Self {
                 status: *result,
                 common: od,
             },
@@ -274,11 +274,7 @@ impl Unblockable for SignalExternalWfResult {
     fn unblock(ue: UnblockEvent, _: Self::OtherDat) -> Self {
         match ue {
             UnblockEvent::SignalExternal(_, maybefail) => {
-                if let Some(f) = maybefail {
-                    Err(f)
-                } else {
-                    Ok(SignalExternalOk)
-                }
+                maybefail.map_or(Ok(SignalExternalOk), Err)
             }
             _ => panic!("Invalid unblock event for signal external workflow result"),
         }
@@ -290,11 +286,7 @@ impl Unblockable for CancelExternalWfResult {
     fn unblock(ue: UnblockEvent, _: Self::OtherDat) -> Self {
         match ue {
             UnblockEvent::CancelExternal(_, maybefail) => {
-                if let Some(f) = maybefail {
-                    Err(f)
-                } else {
-                    Ok(CancelExternalOk)
-                }
+                maybefail.map_or(Ok(CancelExternalOk), Err)
             }
             _ => panic!("Invalid unblock event for signal external workflow result"),
         }

package/sdk-core/src/telemetry/metrics.rs

@@ -360,16 +360,14 @@ impl AggregatorSelector for SDKAggSelector {
         if *descriptor.instrument_kind() == InstrumentKind::ValueRecorder {
             // Some recorders are just gauges
             match descriptor.name() {
-                STICKY_CACHE_SIZE_NAME => return Some(Arc::new(last_value())),
-                NUM_POLLERS_NAME => return Some(Arc::new(last_value())),
+                STICKY_CACHE_SIZE_NAME | NUM_POLLERS_NAME => return Some(Arc::new(last_value())),
                 _ => (),
             }
 
             // Other recorders will select their appropriate buckets
             let buckets = match descriptor.name() {
                 WF_E2E_LATENCY_NAME => WF_LATENCY_MS_BUCKETS,
-                WF_TASK_EXECUTION_LATENCY_NAME => WF_TASK_MS_BUCKETS,
-                WF_TASK_REPLAY_LATENCY_NAME => WF_TASK_MS_BUCKETS,
+                WF_TASK_EXECUTION_LATENCY_NAME | WF_TASK_REPLAY_LATENCY_NAME => WF_TASK_MS_BUCKETS,
                 WF_TASK_SCHED_TO_START_LATENCY_NAME | ACT_SCHED_TO_START_LATENCY_NAME => {
                     TASK_SCHED_TO_START_MS_BUCKETS
                 }

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

@@ -17,7 +17,7 @@ use opentelemetry::{
 };
 use opentelemetry_otlp::WithExportConfig;
 use parking_lot::{const_mutex, Mutex};
-use std::{collections::VecDeque, net::SocketAddr, ops::Deref, time::Duration};
+use std::{collections::VecDeque, net::SocketAddr, time::Duration};
 use tracing_subscriber::{layer::SubscriberExt, EnvFilter};
 use url::Url;
 
@@ -112,7 +112,7 @@ pub(crate) fn telemetry_init(opts: &TelemetryOptions) -> Result<(), anyhow::Erro
     std::thread::spawn(move || {
         let res = GLOBAL_TELEM_DAT.get_or_try_init::<_, anyhow::Error>(move || {
             // Ensure closure captures the mutex guard
-            let _ = guard.deref();
+            let _ = &*guard;
 
             let runtime = tokio::runtime::Builder::new_multi_thread()
                 .thread_name("telemetry")
@@ -120,13 +120,12 @@ pub(crate) fn telemetry_init(opts: &TelemetryOptions) -> Result<(), anyhow::Erro
                 .enable_all()
                 .build()?;
             let mut globaldat = GlobalTelemDat::default();
-            let mut am_forwarding_logs = false;
+            let am_forwarding_logs = opts.log_forwarding_level != LevelFilter::Off;
 
-            if opts.log_forwarding_level != LevelFilter::Off {
+            if am_forwarding_logs {
                 log::set_max_level(opts.log_forwarding_level);
                 globaldat.core_export_logger =
                     Some(CoreExportLogger::new(opts.log_forwarding_level));
-                am_forwarding_logs = true;
             }
 
             let filter_layer = EnvFilter::try_from_env(LOG_FILTER_ENV_VAR).or_else(|_| {
@@ -232,7 +231,7 @@ pub(crate) fn test_telem_console() {
         log_forwarding_level: LevelFilter::Off,
         prometheus_export_bind_address: None,
     })
-    .unwrap()
+    .unwrap();
 }
 
 #[allow(dead_code)] // Not always used, called to enable for debugging when needed
@@ -244,7 +243,7 @@ pub(crate) fn test_telem_collector() {
         log_forwarding_level: LevelFilter::Off,
         prometheus_export_bind_address: None,
     })
-    .unwrap()
+    .unwrap();
 }
 
 /// A trait for using [Display] on the contents of vecs, etc, which don't implement it.

package/sdk-core/src/test_help/canned_histories.rs

@@ -875,7 +875,7 @@ pub fn long_sequential_timers(num_tasks: usize) -> TestHistoryBuilder {
     t.add_by_type(EventType::WorkflowExecutionStarted);
     t.add_full_wf_task();
 
-    for i in 1..num_tasks + 1 {
+    for i in 1..=num_tasks {
         let timer_started_event_id = t.add_get_event_id(EventType::TimerStarted, None);
         t.add(
             EventType::TimerFired,
@@ -1122,13 +1122,16 @@ pub fn timer_then_continue_as_new(timer_id: &str) -> TestHistoryBuilder {
 /// 10: EVENT_TYPE_WORKFLOW_TASK_COMPLETED
 /// 11: EVENT_TYPE_WORKFLOW_EXECUTION_CANCELED
 pub fn timer_wf_cancel_req_cancelled(timer_id: &str) -> TestHistoryBuilder {
-    timer_cancel_req_then(timer_id, |t| t.add_cancelled())
+    timer_cancel_req_then(timer_id, TestHistoryBuilder::add_cancelled)
 }
 pub fn timer_wf_cancel_req_completed(timer_id: &str) -> TestHistoryBuilder {
-    timer_cancel_req_then(timer_id, |t| t.add_workflow_execution_completed())
+    timer_cancel_req_then(
+        timer_id,
+        TestHistoryBuilder::add_workflow_execution_completed,
+    )
 }
 pub fn timer_wf_cancel_req_failed(timer_id: &str) -> TestHistoryBuilder {
-    timer_cancel_req_then(timer_id, |t| t.add_workflow_execution_failed())
+    timer_cancel_req_then(timer_id, TestHistoryBuilder::add_workflow_execution_failed)
 }
 
 ///  1: EVENT_TYPE_WORKFLOW_EXECUTION_STARTED
@@ -1158,7 +1161,7 @@ pub fn timer_wf_cancel_req_do_another_timer_then_cancelled() -> TestHistoryBuild
             }),
         );
         t.add_full_wf_task();
-        t.add_cancelled()
+        t.add_cancelled();
     })
 }
 

package/sdk-core/src/test_help/history_builder.rs

@@ -182,7 +182,7 @@ impl TestHistoryBuilder {
                     ..Default::default()
                 },
             ),
-        )
+        );
     }
 
     pub fn add_activity_task_cancel_requested(&mut self, scheduled_event_id: i64) {
@@ -358,7 +358,7 @@ impl TestHistoryBuilder {
             },
         )) = &evt.attributes
         {
-            self.original_run_id = original_execution_run_id.to_owned();
+            self.original_run_id = original_execution_run_id.clone();
         };
         self.events.push(evt);
     }

package/sdk-core/src/test_help/history_info.rs

@@ -105,14 +105,14 @@ impl HistoryInfo {
     }
 
     /// Non-test code should *not* rely on just counting workflow tasks b/c of pagination
-    pub(crate) fn wf_task_count(&self) -> usize {
+    pub(crate) const fn wf_task_count(&self) -> usize {
         self.wf_task_count
     }
 }
 
 impl From<HistoryInfo> for HistoryUpdate {
     fn from(v: HistoryInfo) -> Self {
-        HistoryUpdate::new_from_events(v.events, v.previous_started_event_id)
+        Self::new_from_events(v.events, v.previous_started_event_id)
     }
 }