use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use super::Task;
mod timestamp_deserializer {
use chrono::{DateTime, Utc};
use serde::{self, Deserialize, Deserializer};
pub fn deserialize<'de, D>(deserializer: D) -> Result<i64, D::Error>
where
D: Deserializer<'de>,
{
#[derive(Deserialize)]
#[serde(untagged)]
enum TimestampOrString {
Timestamp(i64),
String(String),
}
match TimestampOrString::deserialize(deserializer)? {
TimestampOrString::Timestamp(ts) => Ok(ts),
TimestampOrString::String(s) => {
DateTime::parse_from_rfc3339(&s)
.map(|dt| dt.with_timezone(&Utc).timestamp_millis())
.or_else(|_| {
s.parse::<i64>()
})
.map_err(serde::de::Error::custom)
}
}
}
}
mod flexible_map_deserializer {
use serde::{self, Deserialize, Deserializer};
use std::collections::HashMap;
pub fn deserialize<'de, D>(
deserializer: D,
) -> Result<HashMap<String, serde_json::Value>, D::Error>
where
D: Deserializer<'de>,
{
#[derive(Deserialize)]
#[serde(untagged)]
enum MapOrString {
Map(HashMap<String, serde_json::Value>),
#[expect(dead_code)]
String(String),
}
match MapOrString::deserialize(deserializer)? {
MapOrString::Map(map) => Ok(map),
MapOrString::String(_) => {
Ok(HashMap::new())
}
}
}
}
mod flexible_tasks_deserializer {
use super::Task;
use serde::{self, Deserialize, Deserializer};
pub fn deserialize<'de, D>(deserializer: D) -> Result<Vec<Task>, D::Error>
where
D: Deserializer<'de>,
{
#[derive(Deserialize)]
#[serde(untagged)]
enum VecOrString {
Vec(Vec<Task>),
#[expect(dead_code)]
String(String),
}
match VecOrString::deserialize(deserializer)? {
VecOrString::Vec(vec) => Ok(vec),
VecOrString::String(_) => {
Ok(Vec::new())
}
}
}
}
mod flexible_string_vec_deserializer {
use serde::{self, Deserialize, Deserializer};
pub fn deserialize<'de, D>(deserializer: D) -> Result<Vec<String>, D::Error>
where
D: Deserializer<'de>,
{
#[derive(Deserialize)]
#[serde(untagged)]
enum VecOrString {
Vec(Vec<String>),
Single(String),
}
match VecOrString::deserialize(deserializer)? {
VecOrString::Vec(vec) => Ok(vec),
VecOrString::Single(s) => {
if s.is_empty() {
Ok(Vec::new())
} else {
Ok(vec![s])
}
}
}
}
}
mod flexible_string_map_deserializer {
use serde::{self, Deserialize, Deserializer};
use std::collections::HashMap;
pub fn deserialize<'de, D>(deserializer: D) -> Result<HashMap<String, String>, D::Error>
where
D: Deserializer<'de>,
{
#[derive(Deserialize)]
#[serde(untagged)]
enum MapOrString {
Map(HashMap<String, String>),
#[expect(dead_code)]
String(String),
}
match MapOrString::deserialize(deserializer)? {
MapOrString::Map(map) => Ok(map),
MapOrString::String(_) => {
Ok(HashMap::new())
}
}
}
}
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum WorkflowStatus {
#[default]
Running,
Completed,
Failed,
TimedOut,
Terminated,
Paused,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Workflow {
#[serde(default)]
pub workflow_id: String,
#[serde(default)]
pub workflow_name: String,
#[serde(default)]
pub workflow_version: i32,
#[serde(default)]
pub status: WorkflowStatus,
#[serde(default, deserialize_with = "flexible_map_deserializer::deserialize")]
pub input: HashMap<String, serde_json::Value>,
#[serde(default, deserialize_with = "flexible_map_deserializer::deserialize")]
pub output: HashMap<String, serde_json::Value>,
#[serde(skip_serializing_if = "Option::is_none")]
pub correlation_id: Option<String>,
#[serde(default, deserialize_with = "flexible_tasks_deserializer::deserialize")]
pub tasks: Vec<Task>,
#[serde(skip_serializing_if = "Option::is_none")]
pub parent_workflow_id: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub parent_workflow_task_id: Option<String>,
#[serde(default, deserialize_with = "timestamp_deserializer::deserialize")]
pub start_time: i64,
#[serde(default, deserialize_with = "timestamp_deserializer::deserialize")]
pub end_time: i64,
#[serde(default, deserialize_with = "timestamp_deserializer::deserialize")]
pub update_time: i64,
#[serde(default, deserialize_with = "timestamp_deserializer::deserialize")]
pub create_time: i64,
#[serde(skip_serializing_if = "Option::is_none")]
pub created_by: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub updated_by: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub reason_for_incompletion: Option<String>,
#[serde(default, deserialize_with = "flexible_map_deserializer::deserialize")]
pub variables: HashMap<String, serde_json::Value>,
#[serde(skip_serializing_if = "Option::is_none")]
pub external_input_payload_storage_path: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub external_output_payload_storage_path: Option<String>,
#[serde(default)]
pub priority: i32,
#[serde(skip_serializing_if = "Option::is_none")]
pub owner_app: Option<String>,
#[serde(
default,
deserialize_with = "flexible_string_map_deserializer::deserialize"
)]
pub task_to_domain: HashMap<String, String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub workflow_definition: Option<super::WorkflowDef>,
#[serde(
default,
deserialize_with = "flexible_string_vec_deserializer::deserialize"
)]
pub failed_reference_task_names: Vec<String>,
#[serde(
default,
deserialize_with = "flexible_string_vec_deserializer::deserialize"
)]
pub failed_task_names: Vec<String>,
#[serde(default, deserialize_with = "timestamp_deserializer::deserialize")]
pub last_retried_time: i64,
#[serde(skip_serializing_if = "Option::is_none")]
pub event: Option<String>,
}
impl Workflow {
#[must_use]
pub fn is_terminal(&self) -> bool {
matches!(
self.status,
WorkflowStatus::Completed
| WorkflowStatus::Failed
| WorkflowStatus::Terminated
| WorkflowStatus::TimedOut
)
}
#[must_use]
pub fn is_running(&self) -> bool {
!self.is_terminal()
}
#[must_use]
pub fn is_successful(&self) -> bool {
self.status == WorkflowStatus::Completed
}
#[must_use]
pub fn get_output<T>(&self, key: &str) -> Option<T>
where
T: serde::de::DeserializeOwned,
{
let v = self.output.get(key)?;
serde_json::from_value(v.clone()).ok()
}
#[must_use]
pub fn get_output_string(&self, key: &str) -> Option<String> {
self.output.get(key).map(|v| {
if let serde_json::Value::String(s) = v {
s.clone()
} else {
v.to_string()
}
})
}
#[must_use]
pub fn get_variable<T>(&self, key: &str) -> Option<T>
where
T: serde::de::DeserializeOwned,
{
let v = self.variables.get(key)?;
serde_json::from_value(v.clone()).ok()
}
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct StartWorkflowRequest {
pub name: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<i32>,
#[serde(default)]
pub input: HashMap<String, serde_json::Value>,
#[serde(skip_serializing_if = "Option::is_none")]
pub correlation_id: Option<String>,
#[serde(default)]
pub task_to_domain: HashMap<String, String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub workflow_def: Option<super::WorkflowDef>,
#[serde(skip_serializing_if = "Option::is_none")]
pub external_input_payload_storage_path: Option<String>,
#[serde(default)]
pub priority: i32,
}
impl StartWorkflowRequest {
pub fn new(name: impl Into<String>) -> Self {
Self {
name: name.into(),
..Default::default()
}
}
#[must_use]
pub fn with_version(mut self, version: i32) -> Self {
self.version = Some(version);
self
}
#[must_use]
pub fn with_input(mut self, input: HashMap<String, serde_json::Value>) -> Self {
self.input = input;
self
}
#[must_use]
pub fn with_input_value(mut self, key: impl Into<String>, value: impl Serialize) -> Self {
self.input.insert(
key.into(),
serde_json::to_value(value).unwrap_or(serde_json::Value::Null),
);
self
}
#[must_use]
pub fn with_correlation_id(mut self, id: impl Into<String>) -> Self {
self.correlation_id = Some(id.into());
self
}
#[must_use]
pub fn with_priority(mut self, priority: i32) -> Self {
self.priority = priority;
self
}
#[must_use]
pub fn with_task_to_domain(mut self, mapping: HashMap<String, String>) -> Self {
self.task_to_domain = mapping;
self
}
#[must_use]
pub fn with_workflow_def(mut self, def: super::WorkflowDef) -> Self {
self.workflow_def = Some(def);
self
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_workflow_deserialization() {
let json = r#"{
"workflowId": "wf-123",
"workflowName": "test_workflow",
"status": "RUNNING",
"input": {"key": "value"}
}"#;
let wf: Workflow = serde_json::from_str(json).unwrap();
assert_eq!(wf.workflow_id, "wf-123");
assert_eq!(wf.workflow_name, "test_workflow");
assert_eq!(wf.status, WorkflowStatus::Running);
}
#[test]
fn test_workflow_is_terminal() {
let wf = Workflow {
status: WorkflowStatus::Running,
..Default::default()
};
assert!(!wf.is_terminal());
let wf = Workflow {
status: WorkflowStatus::Completed,
..Default::default()
};
assert!(wf.is_terminal());
assert!(wf.is_successful());
let wf = Workflow {
status: WorkflowStatus::Failed,
..Default::default()
};
assert!(wf.is_terminal());
assert!(!wf.is_successful());
}
#[test]
fn test_start_workflow_request() {
let req = StartWorkflowRequest::new("my_workflow")
.with_version(1)
.with_input_value("name", "test")
.with_correlation_id("corr-123");
assert_eq!(req.name, "my_workflow");
assert_eq!(req.version, Some(1));
assert!(req.input.contains_key("name"));
assert_eq!(req.correlation_id, Some("corr-123".to_owned()));
}
}