1use chrono::{DateTime, Utc};
2use serde::{Deserialize, Serialize};
3
4#[derive(Debug, Clone, Serialize, Deserialize)]
5pub struct Event {
7 pub id: String,
9 pub event_name: String,
11 pub event_key: String,
13 pub event_data: serde_json::Value,
15 pub event_time: DateTime<Utc>,
17 pub is_processed: bool,
19}
20
21impl Event {
22 pub fn new(
23 event_name: impl Into<String>,
24 event_key: impl Into<String>,
25 event_data: serde_json::Value,
26 ) -> Self {
27 Self {
28 id: uuid::Uuid::new_v4().to_string(),
29 event_name: event_name.into(),
30 event_key: event_key.into(),
31 event_data,
32 event_time: Utc::now(),
33 is_processed: false,
34 }
35 }
36}
37
38#[derive(Debug, Clone, Serialize, Deserialize)]
39pub struct EventSubscription {
41 pub id: String,
43 pub workflow_id: String,
45 pub step_id: usize,
47 pub execution_pointer_id: String,
49 pub event_name: String,
51 pub event_key: String,
53 pub subscribe_as_of: DateTime<Utc>,
55 pub subscription_data: Option<serde_json::Value>,
57 pub external_token: Option<String>,
59 pub external_worker_id: Option<String>,
61 pub external_token_expiry: Option<DateTime<Utc>>,
63}
64
65impl EventSubscription {
66 pub fn new(
67 workflow_id: impl Into<String>,
68 step_id: usize,
69 execution_pointer_id: impl Into<String>,
70 event_name: impl Into<String>,
71 event_key: impl Into<String>,
72 subscribe_as_of: DateTime<Utc>,
73 ) -> Self {
74 Self {
75 id: uuid::Uuid::new_v4().to_string(),
76 workflow_id: workflow_id.into(),
77 step_id,
78 execution_pointer_id: execution_pointer_id.into(),
79 event_name: event_name.into(),
80 event_key: event_key.into(),
81 subscribe_as_of,
82 subscription_data: None,
83 external_token: None,
84 external_worker_id: None,
85 external_token_expiry: None,
86 }
87 }
88}
89
90#[cfg(test)]
91mod tests {
92 use super::*;
93 use pretty_assertions::assert_eq;
94
95 #[test]
96 fn new_event_defaults() {
97 let event = Event::new(
98 "order.created",
99 "order-456",
100 serde_json::json!({"amount": 100}),
101 );
102 assert_eq!(event.event_name, "order.created");
103 assert_eq!(event.event_key, "order-456");
104 assert!(!event.is_processed);
105 }
106
107 #[test]
108 fn new_event_generates_unique_ids() {
109 let e1 = Event::new("test", "key", serde_json::json!(null));
110 let e2 = Event::new("test", "key", serde_json::json!(null));
111 assert_ne!(e1.id, e2.id);
112 }
113
114 #[test]
115 fn event_serde_round_trip() {
116 let event = Event::new("test", "key", serde_json::json!({"data": true}));
117 let json = serde_json::to_string(&event).unwrap();
118 let deserialized: Event = serde_json::from_str(&json).unwrap();
119 assert_eq!(event.id, deserialized.id);
120 assert_eq!(event.event_name, deserialized.event_name);
121 assert_eq!(event.event_data, deserialized.event_data);
122 }
123
124 #[test]
125 fn new_subscription_defaults() {
126 let sub = EventSubscription::new("wf-1", 0, "ptr-1", "evt", "key", Utc::now());
127 assert_eq!(sub.workflow_id, "wf-1");
128 assert_eq!(sub.step_id, 0);
129 assert!(sub.external_token.is_none());
130 assert!(sub.subscription_data.is_none());
131 }
132
133 #[test]
134 fn subscription_serde_round_trip() {
135 let sub = EventSubscription::new("wf-1", 2, "ptr-1", "evt", "key", Utc::now());
136 let json = serde_json::to_string(&sub).unwrap();
137 let deserialized: EventSubscription = serde_json::from_str(&json).unwrap();
138 assert_eq!(sub.id, deserialized.id);
139 assert_eq!(sub.workflow_id, deserialized.workflow_id);
140 assert_eq!(sub.event_name, deserialized.event_name);
141 }
142}