WfExitValue

Author: Sushisource

workflow-api/Cargo.toml

@@ -13,6 +13,7 @@ categories = ["development-tools"]
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+anyhow = "1.0"
 futures = "0.3"
 
 [dependencies.temporal-sdk-core-protos]

workflow-api/src/lib.rs

@@ -1,6 +1,17 @@
+//! This needs to be its own crate so that it doesn't pull in anything that would make compiling
+//! to WASM not work. I've already figured out how to do all that once before with my WASM workflows
+//! hackathon
+
 use futures::future::BoxFuture;
-use std::{error::Error, time::Duration};
-use temporal_sdk_core_protos::temporal::api::common::v1::Payload;
+use std::time::Duration;
+use temporal_sdk_core_protos::{
+    coresdk::workflow_commands::ContinueAsNewWorkflowExecution, temporal::api::common::v1::Payload,
+};
+
+// anyhow errors are used for the errors returned by user-defined functions. This makes `?` work
+// well everywhere by default which is a very nice property, as well as preserving backtraces. We
+// may need to define our own error type instead to allow attaching things like the non-retryable
+// flag... but I suspect we can just make downcasting work for that.
 
 /// Workflow authors must implement this trait to create Temporal Rust workflows
 pub trait Workflow: Sized {
@@ -22,7 +33,10 @@ pub trait Workflow: Sized {
     ///
     /// `ctx` should be used to perform various Temporal commands like starting timers and
     /// activities.
-    fn run(&mut self, ctx: WfContext) -> BoxFuture<Self::Output>;
+    fn run(
+        &mut self,
+        ctx: WfContext,
+    ) -> BoxFuture<Result<WfExitValue<Self::Output>, anyhow::Error>>;
 
     /// All signals this workflow can handle. Typically you won't implement this directly, it will
     /// automatically contain all signals defined with the `#[signal]` attribute.
@@ -38,13 +52,30 @@ pub trait Workflow: Sized {
     }
 }
 
+/// TODO: Exists in SDK in slightly different form, and would move into this crate
+#[derive(Debug)]
+pub enum WfExitValue<T: TemporalSerializable> {
+    /// Continue the workflow as a new execution
+    ContinueAsNew(Box<ContinueAsNewWorkflowExecution>), // Wouldn't be raw proto in reality
+    /// Confirm the workflow was cancelled
+    Cancelled,
+    /// Finish with a result
+    Normal(T),
+}
+impl<T: TemporalSerializable> From<T> for WfExitValue<T> {
+    fn from(v: T) -> Self {
+        Self::Normal(v)
+    }
+}
+// ... also convenience functions for constructing C-A-N, etc.
+
 /// A workflow context which contains only information, but does not allow any commands to
 /// be created.
 pub struct SafeWfContext {
     // TODO
 }
 
-/// TODO: Placeholder, move from SDK
+/// TODO: Placeholder, exists in SDK and would move into this crate & (likely) become a trait
 pub struct WfContext {}
 impl WfContext {
     pub async fn timer(&self, _: Duration) {
@@ -53,26 +84,25 @@ impl WfContext {
 }
 
 pub struct SignalDefinition<WF: Workflow> {
-    // TODO: Could be a matching predicate
+    // TODO: Could be a matching predicate, to allow for dynamic registration
     name: String,
     // The handler input type must be erased here, since otherwise we couldn't store/return the
     // heterogeneous collection of definition types in the workflow itself. The signal macro
-    // will wrap the user's function with code that performs deserialization, as well as error
-    // boxing.
-    handler: Box<dyn FnMut(&mut WF, Payload) -> Result<(), Box<dyn Error>>>,
+    // will wrap the user's function with code that performs deserialization.
+    handler: Box<dyn FnMut(&mut WF, Payload) -> Result<(), anyhow::Error>>,
 }
 pub struct QueryDefinition<WF: Workflow> {
-    // TODO: Could be a matching predicate
+    // TODO: Could be a matching predicate, to allow for dynamic registration
     name: String,
     // The query macro will wrap the user's function with code that performs deserialization of
     // input and serialization of output, as well as error boxing.
-    handler: Box<dyn FnMut(&WF, Payload) -> Result<Payload, Box<dyn Error>>>,
+    handler: Box<dyn FnMut(&WF, Payload) -> Result<Payload, anyhow::Error>>,
 }
 
-/// TODO: Placeholder, move from (and improve in) SDK
+/// TODO: Placeholders, likely belong inside protos crate. These will be auto-implemented for
+///   anything using serde already (which I expect is how virtually everyone will do this).
 pub trait TemporalSerializable {}
 impl<T> TemporalSerializable for T {}
-/// TODO: Placeholder, move from (and improve in) SDK
 pub trait TemporalDeserializable {}
 impl<T> TemporalDeserializable for T {}
 
@@ -99,11 +129,18 @@ mod tests {
             Self { foo: 0, bar }
         }
 
-        fn run(&mut self, ctx: WfContext) -> BoxFuture<Self::Output> {
+        fn run(
+            &mut self,
+            ctx: WfContext,
+        ) -> BoxFuture<Result<WfExitValue<Self::Output>, anyhow::Error>> {
             async move {
                 ctx.timer(Duration::from_secs(1)).await;
                 self.foo = 1;
-                self.foo
+                // The into() is unfortunately unavoidable without making C-A-N and confirm cancel
+                // be errors instead. Personally, I don't love that and I think it's not idiomatic
+                // Rust, whereas needing to `into()` something is. Other way would be macros, but
+                // it's slightly too much magic I think.
+                Ok(self.foo.into())
             }
             .boxed()
             // TODO: The need to box here is slightly unfortunate, but it's either that or require
@@ -114,7 +151,7 @@ mod tests {
 
     // #[workflow] miiiight be necessary here, but, ideally is not.
     impl MyWorkflow {
-        // Attrib commented out since nonexistent for now, but that's what it'd look like.
+        // Attrib commented out since it's nonexistent for now, but that's what it'd look like.
         // #[signal]
         pub fn my_signal(&mut self, arg: String) {
             self.bar.insert(arg, 1);
@@ -139,7 +176,7 @@ mod tests {
     }
     impl MyWorkflowClientExtension for WorkflowHandle<MyWorkflow> {
         fn my_signal(&self, arg: String) -> BoxFuture<Result<(), SignalError>> {
-            // Is actually something like:
+            // Becomes something like:
             // self.signal("my_signal", arg.serialize())
             todo!()
         }
@@ -157,4 +194,7 @@ mod tests {
         };
         let _ = wfh.my_signal("hi!".to_string()).await;
     }
+
+    #[test]
+    fn compile() {}
 }