@temporalio/core-bridge 0.23.0 → 1.0.0

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

@@ -26,12 +26,11 @@ pub mod coresdk {
     tonic::include_proto!("coresdk");
 
     use crate::temporal::api::{
-        common::v1::{ActivityType, Payloads, WorkflowExecution},
+        common::v1::{ActivityType, Payload, Payloads, WorkflowExecution},
         failure::v1::{failure::FailureInfo, ApplicationFailureInfo, Failure},
         workflowservice::v1::PollActivityTaskQueueResponse,
     };
     use activity_task::ActivityTask;
-    use common::Payload;
     use serde::{Deserialize, Serialize};
     use std::{
         collections::HashMap,
@@ -79,12 +78,9 @@ pub mod coresdk {
     #[allow(clippy::module_inception)]
     pub mod activity_result {
         tonic::include_proto!("coresdk.activity_result");
-        use super::{
-            super::temporal::api::{
-                common::v1::Payload as APIPayload,
-                failure::v1::{failure, CanceledFailureInfo, Failure as APIFailure},
-            },
-            common::Payload,
+        use super::super::temporal::api::{
+            common::v1::Payload,
+            failure::v1::{failure, CanceledFailureInfo, Failure as APIFailure},
         };
         use crate::temporal::api::{enums::v1::TimeoutType, failure::v1::TimeoutFailureInfo};
         use activity_execution_result as aer;
@@ -175,13 +171,11 @@ pub mod coresdk {
             }
         }
 
-        impl From<Result<APIPayload, APIFailure>> for ActivityExecutionResult {
-            fn from(r: Result<APIPayload, APIFailure>) -> Self {
+        impl From<Result<Payload, APIFailure>> for ActivityExecutionResult {
+            fn from(r: Result<Payload, APIFailure>) -> Self {
                 Self {
                     status: match r {
-                        Ok(p) => Some(aer::Status::Completed(Success {
-                            result: Some(p.into()),
-                        })),
+                        Ok(p) => Some(aer::Status::Completed(Success { result: Some(p) })),
                         Err(f) => Some(aer::Status::Failed(Failure { failure: Some(f) })),
                     },
                 }
@@ -258,51 +252,9 @@ pub mod coresdk {
         use super::external_data::LocalActivityMarkerData;
         use crate::{
             coresdk::{AsJsonPayloadExt, IntoPayloadsExt},
-            temporal::api::common::v1::{Payload as ApiPayload, Payloads},
-        };
-        use std::{
-            collections::HashMap,
-            fmt::{Display, Formatter},
+            temporal::api::common::v1::{Payload, Payloads},
         };
-
-        impl<T> From<T> for Payload
-        where
-            T: AsRef<[u8]>,
-        {
-            fn from(v: T) -> Self {
-                // TODO: Set better encodings, whole data converter deal. Setting anything for now
-                //  at least makes it show up in the web UI.
-                let mut metadata = HashMap::new();
-                metadata.insert("encoding".to_string(), b"binary/plain".to_vec());
-                Self {
-                    metadata,
-                    data: v.as_ref().to_vec(),
-                }
-            }
-        }
-
-        impl Payload {
-            // Is it's own function b/c asref causes implementation conflicts
-            pub fn as_slice(&self) -> &[u8] {
-                self.data.as_slice()
-            }
-        }
-
-        impl Display for Payload {
-            fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-                if self.data.len() > 64 {
-                    let mut windows = self.data.as_slice().windows(32);
-                    write!(
-                        f,
-                        "[{}..{}]",
-                        base64::encode(windows.next().unwrap_or_default()),
-                        base64::encode(windows.next_back().unwrap_or_default())
-                    )
-                } else {
-                    write!(f, "[{}]", base64::encode(&self.data))
-                }
-            }
-        }
+        use std::collections::HashMap;
 
         pub fn build_has_change_marker_details(
             patch_id: &str,
@@ -356,7 +308,7 @@ pub mod coresdk {
         /// map.
         pub fn extract_local_activity_marker_details(
             details: &mut HashMap<String, Payloads>,
-        ) -> (Option<LocalActivityMarkerData>, Option<ApiPayload>) {
+        ) -> (Option<LocalActivityMarkerData>, Option<Payload>) {
             let data = extract_local_activity_marker_data(details);
             let result = details.remove("result").and_then(|mut p| p.payloads.pop());
             (data, result)
@@ -438,9 +390,8 @@ pub mod coresdk {
     pub mod workflow_activation {
         use crate::{
             coresdk::{
-                common::{NamespacedWorkflowExecution, Payload},
-                workflow_activation::remove_from_cache::EvictionReason,
-                FromPayloadsExt,
+                common::NamespacedWorkflowExecution,
+                workflow_activation::remove_from_cache::EvictionReason, FromPayloadsExt,
             },
             temporal::api::{
                 common::v1::Header,
@@ -468,6 +419,7 @@ pub mod coresdk {
                 timestamp: None,
                 run_id,
                 is_replaying: false,
+                history_length: 0,
                 jobs: vec![WorkflowActivationJob::from(
                     workflow_activation_job::Variant::RemoveFromCache(RemoveFromCache {
                         message,
@@ -477,21 +429,6 @@ pub mod coresdk {
             }
         }
 
-        pub fn create_query_activation(
-            run_id: String,
-            queries: impl IntoIterator<Item = QueryWorkflow>,
-        ) -> WorkflowActivation {
-            WorkflowActivation {
-                timestamp: None,
-                run_id,
-                is_replaying: false,
-                jobs: queries
-                    .into_iter()
-                    .map(|qr| workflow_activation_job::Variant::QueryWorkflow(qr).into())
-                    .collect(),
-            }
-        }
-
         pub fn query_to_job(id: String, q: WorkflowQuery) -> QueryWorkflow {
             QueryWorkflow {
                 query_id: id,
@@ -669,10 +606,7 @@ pub mod coresdk {
                 randomness_seed,
                 headers: match attrs.header {
                     None => HashMap::new(),
-                    Some(Header { fields }) => fields
-                        .into_iter()
-                        .map(|(k, v)| (k, Payload::from(v)))
-                        .collect(),
+                    Some(Header { fields }) => fields,
                 },
                 identity: attrs.identity,
                 parent_workflow_info: attrs.parent_workflow_execution.map(|pe| {
@@ -834,7 +768,11 @@ pub mod coresdk {
 
         impl Display for UpsertWorkflowSearchAttributes {
             fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-                write!(f, "UpsertWorkflowSearchAttributes({})", self.seq) // todo: customize this better
+                write!(
+                    f,
+                    "UpsertWorkflowSearchAttributes({:?})",
+                    self.search_attributes.keys()
+                )
             }
         }
 
@@ -1030,6 +968,14 @@ pub mod coresdk {
             }
             false
         }
+
+        /// Returns true if the activation completion is a success with no commands
+        pub fn is_empty(&self) -> bool {
+            if let Some(workflow_activation_completion::Status::Successful(s)) = &self.status {
+                return s.commands.is_empty();
+            }
+            false
+        }
     }
 
     /// Makes converting outgoing lang commands into [WorkflowActivationCompletion]s easier
@@ -1110,7 +1056,7 @@ pub mod coresdk {
                     activity_task::Start {
                         workflow_namespace: r.workflow_namespace,
                         workflow_type: r.workflow_type.map_or_else(|| "".to_string(), |wt| wt.name),
-                        workflow_execution: Some(common::WorkflowExecution {
+                        workflow_execution: Some(WorkflowExecution {
                             workflow_id,
                             run_id,
                         }),
@@ -1146,15 +1092,6 @@ pub mod coresdk {
         }
     }
 
-    impl From<common::WorkflowExecution> for WorkflowExecution {
-        fn from(exc: common::WorkflowExecution) -> Self {
-            Self {
-                workflow_id: exc.workflow_id,
-                run_id: exc.run_id,
-            }
-        }
-    }
-
     impl Failure {
         pub fn is_timeout(&self) -> bool {
             matches!(self.failure_info, Some(FailureInfo::TimeoutFailureInfo(_)))
@@ -1247,30 +1184,12 @@ pub mod coresdk {
         }
     }
 
-    impl From<common::Payload> for super::temporal::api::common::v1::Payload {
-        fn from(p: Payload) -> Self {
-            Self {
-                metadata: p.metadata,
-                data: p.data,
-            }
-        }
-    }
-
-    impl From<super::temporal::api::common::v1::Payload> for common::Payload {
-        fn from(p: super::temporal::api::common::v1::Payload) -> Self {
-            Self {
-                metadata: p.metadata,
-                data: p.data,
-            }
-        }
-    }
-
     pub trait FromPayloadsExt {
         fn from_payloads(p: Option<Payloads>) -> Self;
     }
     impl<T> FromPayloadsExt for T
     where
-        T: FromIterator<common::Payload>,
+        T: FromIterator<Payload>,
     {
         fn from_payloads(p: Option<Payloads>) -> Self {
             match p {
@@ -1285,7 +1204,7 @@ pub mod coresdk {
     }
     impl<T> IntoPayloadsExt for T
     where
-        T: IntoIterator<Item = common::Payload>,
+        T: IntoIterator<Item = Payload>,
     {
         fn into_payloads(self) -> Option<Payloads> {
             let mut iterd = self.into_iter().peekable();
@@ -1299,27 +1218,9 @@ pub mod coresdk {
         }
     }
 
-    impl From<common::Payload> for Payloads {
+    impl From<Payload> for Payloads {
         fn from(p: Payload) -> Self {
-            Self {
-                payloads: vec![p.into()],
-            }
-        }
-    }
-
-    impl<T> From<T> for super::temporal::api::common::v1::Payload
-    where
-        T: AsRef<[u8]>,
-    {
-        fn from(v: T) -> Self {
-            // TODO: Set better encodings, whole data converter deal. Setting anything for now
-            //  at least makes it show up in the web UI.
-            let mut metadata = HashMap::new();
-            metadata.insert("encoding".to_string(), b"binary/plain".to_vec());
-            Self {
-                metadata,
-                data: v.as_ref().to_vec(),
-            }
+            Self { payloads: vec![p] }
         }
     }
 
@@ -1383,13 +1284,13 @@ pub mod coresdk {
         }
     }
 
-    /// Errors when converting from a [Payloads] api proto to our internal [common::Payload]
+    /// Errors when converting from a [Payloads] api proto to our internal [Payload]
     #[derive(derive_more::Display, Debug)]
     pub enum PayloadsToPayloadError {
         MoreThanOnePayload,
         NoPayload,
     }
-    impl TryFrom<Payloads> for common::Payload {
+    impl TryFrom<Payloads> for Payload {
         type Error = PayloadsToPayloadError;
 
         fn try_from(mut v: Payloads) -> Result<Self, Self::Error> {
@@ -1397,7 +1298,7 @@ pub mod coresdk {
                 None => Err(PayloadsToPayloadError::NoPayload),
                 Some(p) => {
                     if v.payloads.is_empty() {
-                        Ok(p.into())
+                        Ok(p)
                     } else {
                         Err(PayloadsToPayloadError::MoreThanOnePayload)
                     }
@@ -1517,7 +1418,6 @@ pub mod temporal {
                                 activity_type: Some(ActivityType {
                                     name: s.activity_type,
                                 }),
-                                namespace: s.namespace,
                                 task_queue: Some(s.task_queue.into()),
                                 header: Some(s.headers.into()),
                                 input: s.arguments.into_payloads(),
@@ -1526,6 +1426,7 @@ pub mod temporal {
                                 start_to_close_timeout: s.start_to_close_timeout,
                                 heartbeat_timeout: s.heartbeat_timeout,
                                 retry_policy: s.retry_policy.map(Into::into),
+                                request_eager_execution: !s.do_not_eagerly_execute,
                             },
                         )
                     }
@@ -1622,25 +1523,48 @@ pub mod temporal {
         }
         pub mod common {
             pub mod v1 {
-                use crate::coresdk::common;
                 use std::{
                     collections::HashMap,
                     fmt::{Display, Formatter},
                 };
                 tonic::include_proto!("temporal.api.common.v1");
 
-                impl From<HashMap<String, common::Payload>> for Header {
-                    fn from(h: HashMap<String, common::Payload>) -> Self {
+                impl<T> From<T> for Payload
+                where
+                    T: AsRef<[u8]>,
+                {
+                    fn from(v: T) -> Self {
+                        // TODO: Set better encodings, whole data converter deal. Setting anything
+                        //  for now at least makes it show up in the web UI.
+                        let mut metadata = HashMap::new();
+                        metadata.insert("encoding".to_string(), b"binary/plain".to_vec());
                         Self {
-                            fields: h.into_iter().map(|(k, v)| (k, v.into())).collect(),
+                            metadata,
+                            data: v.as_ref().to_vec(),
                         }
                     }
                 }
 
+                impl Payload {
+                    // Is its own function b/c asref causes implementation conflicts
+                    pub fn as_slice(&self) -> &[u8] {
+                        self.data.as_slice()
+                    }
+                }
+
                 impl Display for Payload {
                     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-                        // Attempt to render payloads as strings
-                        write!(f, "{}", std::str::from_utf8(&self.data).unwrap_or_default())
+                        if self.data.len() > 64 {
+                            let mut windows = self.data.as_slice().windows(32);
+                            write!(
+                                f,
+                                "[{}..{}]",
+                                base64::encode(windows.next().unwrap_or_default()),
+                                base64::encode(windows.next_back().unwrap_or_default())
+                            )
+                        } else {
+                            write!(f, "[{}]", base64::encode(&self.data))
+                        }
                     }
                 }
 
@@ -1655,51 +1579,19 @@ pub mod temporal {
                     }
                 }
 
-                impl From<Header> for HashMap<String, common::Payload> {
+                impl From<Header> for HashMap<String, Payload> {
                     fn from(h: Header) -> Self {
                         h.fields.into_iter().map(|(k, v)| (k, v.into())).collect()
                     }
                 }
 
-                impl From<HashMap<String, common::Payload>> for Memo {
-                    fn from(h: HashMap<String, common::Payload>) -> Self {
-                        Self {
-                            fields: h.into_iter().map(|(k, v)| (k, v.into())).collect(),
-                        }
-                    }
-                }
-
-                impl From<HashMap<String, common::Payload>> for SearchAttributes {
-                    fn from(h: HashMap<String, common::Payload>) -> Self {
+                impl From<HashMap<String, Payload>> for SearchAttributes {
+                    fn from(h: HashMap<String, Payload>) -> Self {
                         Self {
                             indexed_fields: h.into_iter().map(|(k, v)| (k, v.into())).collect(),
                         }
                     }
                 }
-
-                impl From<common::RetryPolicy> for RetryPolicy {
-                    fn from(r: common::RetryPolicy) -> Self {
-                        Self {
-                            initial_interval: r.initial_interval,
-                            backoff_coefficient: r.backoff_coefficient,
-                            maximum_interval: r.maximum_interval,
-                            maximum_attempts: r.maximum_attempts,
-                            non_retryable_error_types: r.non_retryable_error_types,
-                        }
-                    }
-                }
-
-                impl From<RetryPolicy> for common::RetryPolicy {
-                    fn from(r: RetryPolicy) -> Self {
-                        Self {
-                            initial_interval: r.initial_interval,
-                            backoff_coefficient: r.backoff_coefficient,
-                            maximum_interval: r.maximum_interval,
-                            maximum_attempts: r.maximum_attempts,
-                            non_retryable_error_types: r.non_retryable_error_types,
-                        }
-                    }
-                }
             }
         }
         pub mod history {
@@ -1836,6 +1728,12 @@ pub mod temporal {
             }
         }
 
+        pub mod schedule {
+            pub mod v1 {
+                tonic::include_proto!("temporal.api.schedule.v1");
+            }
+        }
+
         pub mod taskqueue {
             pub mod v1 {
                 use crate::temporal::api::enums::v1::TaskQueueKind;