@temporalio/core-bridge 0.16.4 → 0.18.0

package/sdk-core/{src → core/src/workflow}/machines/child_workflow_state_machine.rs

@@ -1,4 +1,4 @@
-use crate::machines::{
+use super::{
     workflow_machines::MachineResponse, Cancellable, EventInfo, MachineKind, NewMachineWithCommand,
     OnEventWrapper, WFMachinesAdapter, WFMachinesError,
 };
@@ -7,8 +7,7 @@ use std::convert::{TryFrom, TryInto};
 use temporal_sdk_core_protos::{
     coresdk::{
         child_workflow::{
-            self as wfr, child_workflow_result::Status as ChildWorkflowStatus,
-            ChildWorkflowCancellationType, ChildWorkflowResult,
+            self as wfr, child_workflow_result::Status as ChildWorkflowStatus, ChildWorkflowResult,
         },
         common::Payload,
         workflow_activation::{
@@ -115,7 +114,6 @@ impl StartCommandCreated {
             StartEventRecorded::default(),
             SharedState {
                 initiated_event_id,
-                attrs: None, // Drop the attributes to avoid holding large payloads in memory
                 ..state
             },
         )
@@ -303,19 +301,15 @@ pub(super) struct SharedState {
     workflow_id: String,
     run_id: String,
     workflow_type: String,
-    cancellation_type: ChildWorkflowCancellationType,
     cancelled_before_sent: bool,
-    attrs: Option<StartChildWorkflowExecution>,
 }
 
 /// 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<ChildWorkflowMachine> {
+pub(super) fn new_child_workflow(attribs: StartChildWorkflowExecution) -> NewMachineWithCommand {
     let (wf, add_cmd) = ChildWorkflowMachine::new_scheduled(attribs);
     NewMachineWithCommand {
         command: add_cmd,
-        machine: wf,
+        machine: wf.into(),
     }
 }
 
@@ -329,11 +323,6 @@ impl ChildWorkflowMachine {
                 workflow_id: attribs.workflow_id.clone(),
                 workflow_type: attribs.workflow_type.clone(),
                 namespace: attribs.namespace.clone(),
-                cancellation_type: ChildWorkflowCancellationType::from_i32(
-                    attribs.cancellation_type,
-                )
-                .unwrap(),
-                attrs: Some(attribs.clone()),
                 ..Default::default()
             },
         };
@@ -628,15 +617,15 @@ fn convert_payloads(
 mod test {
     use super::*;
     use crate::{
-        prototype_rust_sdk::{
-            CancellableFuture, ChildWorkflowOptions, WfContext, WorkflowFunction, WorkflowResult,
-        },
-        test_help::{canned_histories, TestHistoryBuilder},
+        replay::TestHistoryBuilder, test_help::canned_histories,
         workflow::managed_wf::ManagedWFFunc,
     };
     use anyhow::anyhow;
     use rstest::{fixture, rstest};
     use std::mem::discriminant;
+    use temporal_sdk::{
+        CancellableFuture, ChildWorkflowOptions, WfContext, WorkflowFunction, WorkflowResult,
+    };
     use temporal_sdk_core_protos::coresdk::{
         child_workflow::child_workflow_result,
         workflow_activation::resolve_child_workflow_execution_start::Status as StartStatus,
@@ -684,7 +673,7 @@ mod test {
         ManagedWFFunc::new(t, func, vec![[Expectation::StartFailure as u8].into()])
     }
 
-    async fn parent_wf(mut ctx: WfContext) -> WorkflowResult<()> {
+    async fn parent_wf(ctx: WfContext) -> WorkflowResult<()> {
         let expectation = Expectation::try_from_u8(ctx.get_args()[0].data[0]).unwrap();
         let child = ctx.child_workflow(ChildWorkflowOptions {
             workflow_id: "child-id-1".to_string(),
@@ -692,7 +681,7 @@ mod test {
             ..Default::default()
         });
 
-        let start_res = child.start(&mut ctx).await;
+        let start_res = child.start(&ctx).await;
         match (expectation, &start_res.status) {
             (Expectation::Success | Expectation::Failure, StartStatus::Succeeded(_)) => {}
             (Expectation::StartFailure, StartStatus::Failed(_)) => return Ok(().into()),
@@ -718,7 +707,7 @@ mod test {
     #[tokio::test]
     async fn single_child_workflow_until_completion(mut wfm: ManagedWFFunc) {
         wfm.get_next_activation().await.unwrap();
-        let commands = wfm.get_server_commands().await.commands;
+        let commands = wfm.get_server_commands().commands;
         assert_eq!(commands.len(), 1);
         assert_eq!(
             commands[0].command_type,
@@ -726,13 +715,13 @@ mod test {
         );
 
         wfm.get_next_activation().await.unwrap();
-        let commands = wfm.get_server_commands().await.commands;
+        let commands = wfm.get_server_commands().commands;
         // Workflow is activated because the child WF has started.
         // It does not generate any commands, just waits for completion.
         assert_eq!(commands.len(), 0);
 
         wfm.get_next_activation().await.unwrap();
-        let commands = wfm.get_server_commands().await.commands;
+        let commands = wfm.get_server_commands().commands;
         assert_eq!(commands.len(), 1);
         assert_eq!(
             commands[0].command_type,
@@ -745,7 +734,7 @@ mod test {
     #[tokio::test]
     async fn single_child_workflow_start_fail(mut wfm: ManagedWFFunc) {
         wfm.get_next_activation().await.unwrap();
-        let commands = wfm.get_server_commands().await.commands;
+        let commands = wfm.get_server_commands().commands;
         assert_eq!(commands.len(), 1);
         assert_eq!(
             commands[0].command_type,
@@ -753,7 +742,7 @@ mod test {
         );
 
         wfm.get_next_activation().await.unwrap();
-        let commands = wfm.get_server_commands().await.commands;
+        let commands = wfm.get_server_commands().commands;
         assert_eq!(commands.len(), 1);
         assert_eq!(
             commands[0].command_type,
@@ -762,15 +751,15 @@ mod test {
         wfm.shutdown().await.unwrap();
     }
 
-    async fn cancel_before_send_wf(mut ctx: WfContext) -> WorkflowResult<()> {
+    async fn cancel_before_send_wf(ctx: WfContext) -> WorkflowResult<()> {
         let workflow_id = "child-id-1";
         let child = ctx.child_workflow(ChildWorkflowOptions {
             workflow_id: workflow_id.to_string(),
             workflow_type: "child".to_string(),
             ..Default::default()
         });
-        let start = child.start(&mut ctx);
-        start.cancel(&mut ctx);
+        let start = child.start(&ctx);
+        start.cancel(&ctx);
         match start.await.status {
             StartStatus::Cancelled(_) => Ok(().into()),
             _ => Err(anyhow!("Unexpected start status")),
@@ -792,12 +781,12 @@ mod test {
     #[tokio::test]
     async fn single_child_workflow_cancel_before_sent(mut wfm: ManagedWFFunc) {
         wfm.get_next_activation().await.unwrap();
-        let commands = wfm.get_server_commands().await.commands;
+        let commands = wfm.get_server_commands().commands;
         // Workflow starts and cancels the child workflow, no commands should be sent to server.
         assert_eq!(commands.len(), 0);
 
         wfm.get_next_activation().await.unwrap();
-        let commands = wfm.get_server_commands().await.commands;
+        let commands = wfm.get_server_commands().commands;
         assert_eq!(commands.len(), 1);
         assert_eq!(
             commands[0].command_type,

package/sdk-core/{src → core/src/workflow}/machines/complete_workflow_state_machine.rs

@@ -1,4 +1,4 @@
-use crate::machines::{
+use super::{
     workflow_machines::MachineResponse, Cancellable, EventInfo, MachineKind, NewMachineWithCommand,
     OnEventWrapper, WFMachinesAdapter, WFMachinesError,
 };
@@ -34,13 +34,11 @@ pub(super) enum CompleteWFCommand {
 }
 
 /// Complete a workflow
-pub(super) fn complete_workflow(
-    attribs: CompleteWorkflowExecution,
-) -> NewMachineWithCommand<CompleteWorkflowMachine> {
+pub(super) fn complete_workflow(attribs: CompleteWorkflowExecution) -> NewMachineWithCommand {
     let (machine, add_cmd) = CompleteWorkflowMachine::new_scheduled(attribs);
     NewMachineWithCommand {
         command: add_cmd,
-        machine,
+        machine: machine.into(),
     }
 }
 

package/sdk-core/{src → core/src/workflow}/machines/continue_as_new_workflow_state_machine.rs

@@ -1,4 +1,4 @@
-use crate::machines::{
+use super::{
     Cancellable, EventInfo, HistoryEvent, MachineKind, MachineResponse, NewMachineWithCommand,
     OnEventWrapper, WFMachinesAdapter, WFMachinesError,
 };
@@ -29,9 +29,7 @@ fsm! {
 #[derive(Debug, derive_more::Display)]
 pub(super) enum ContinueAsNewWorkflowCommand {}
 
-pub(super) fn continue_as_new(
-    attribs: ContinueAsNewWorkflowExecution,
-) -> NewMachineWithCommand<ContinueAsNewWorkflowMachine> {
+pub(super) fn continue_as_new(attribs: ContinueAsNewWorkflowExecution) -> NewMachineWithCommand {
     let mut machine = ContinueAsNewWorkflowMachine {
         state: Created {}.into(),
         shared_state: (),
@@ -42,7 +40,10 @@ pub(super) fn continue_as_new(
         command_type: CommandType::ContinueAsNewWorkflowExecution as i32,
         attributes: Some(attribs.into()),
     };
-    NewMachineWithCommand { command, machine }
+    NewMachineWithCommand {
+        command,
+        machine: machine.into(),
+    }
 }
 
 #[derive(Default, Clone)]
@@ -120,19 +121,18 @@ impl Cancellable for ContinueAsNewWorkflowMachine {}
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::{
-        prototype_rust_sdk::{WfContext, WfExitValue, WorkflowFunction, WorkflowResult},
-        test_help::canned_histories,
-        workflow::managed_wf::ManagedWFFunc,
-    };
+    use crate::{test_help::canned_histories, workflow::managed_wf::ManagedWFFunc};
     use std::time::Duration;
+    use temporal_sdk::{WfContext, WfExitValue, WorkflowFunction, WorkflowResult};
 
-    async fn wf_with_timer(mut ctx: WfContext) -> WorkflowResult<()> {
+    async fn wf_with_timer(ctx: WfContext) -> WorkflowResult<()> {
         ctx.timer(Duration::from_millis(500)).await;
-        Ok(WfExitValue::ContinueAsNew(ContinueAsNewWorkflowExecution {
-            arguments: vec![[1].into()],
-            ..Default::default()
-        }))
+        Ok(WfExitValue::continue_as_new(
+            ContinueAsNewWorkflowExecution {
+                arguments: vec![[1].into()],
+                ..Default::default()
+            },
+        ))
     }
 
     #[tokio::test]
@@ -141,12 +141,12 @@ mod tests {
         let t = canned_histories::timer_then_continue_as_new("1");
         let mut wfm = ManagedWFFunc::new(t, func, vec![]);
         wfm.get_next_activation().await.unwrap();
-        let commands = wfm.get_server_commands().await.commands;
+        let commands = wfm.get_server_commands().commands;
         assert_eq!(commands.len(), 1);
         assert_eq!(commands[0].command_type, CommandType::StartTimer as i32);
 
         wfm.get_next_activation().await.unwrap();
-        let commands = wfm.get_server_commands().await.commands;
+        let commands = wfm.get_server_commands().commands;
         assert_eq!(commands.len(), 1);
         assert_eq!(
             commands[0].command_type,
@@ -154,7 +154,7 @@ mod tests {
         );
 
         assert!(wfm.get_next_activation().await.unwrap().jobs.is_empty());
-        let commands = wfm.get_server_commands().await.commands;
+        let commands = wfm.get_server_commands().commands;
         assert_eq!(commands.len(), 0);
         wfm.shutdown().await.unwrap();
     }

package/sdk-core/{src → core/src/workflow}/machines/fail_workflow_state_machine.rs

@@ -1,12 +1,13 @@
-use crate::machines::{
+use super::{
     workflow_machines::MachineResponse, Cancellable, EventInfo, MachineKind, NewMachineWithCommand,
-    OnEventWrapper, ProtoCommand, WFMachinesAdapter, WFMachinesError,
+    OnEventWrapper, WFMachinesAdapter, WFMachinesError,
 };
 use rustfsm::{fsm, TransitionResult};
 use std::convert::TryFrom;
 use temporal_sdk_core_protos::{
     coresdk::workflow_commands::FailWorkflowExecution,
     temporal::api::{
+        command::v1::Command as ProtoCommand,
         enums::v1::{CommandType, EventType},
         history::v1::HistoryEvent,
     },
@@ -30,13 +31,11 @@ pub(super) enum FailWFCommand {
 }
 
 /// Fail a workflow
-pub(super) fn fail_workflow(
-    attribs: FailWorkflowExecution,
-) -> NewMachineWithCommand<FailWorkflowMachine> {
+pub(super) fn fail_workflow(attribs: FailWorkflowExecution) -> NewMachineWithCommand {
     let (machine, add_cmd) = FailWorkflowMachine::new_scheduled(attribs);
     NewMachineWithCommand {
         command: add_cmd,
-        machine,
+        machine: machine.into(),
     }
 }