Skip to main content

wfe_core/models/
event.rs

1use chrono::{DateTime, Utc};
2use serde::{Deserialize, Serialize};
3
4#[derive(Debug, Clone, Serialize, Deserialize)]
5/// Event.
6pub struct Event {
7    /// Id.
8    pub id: String,
9    /// Event name.
10    pub event_name: String,
11    /// Event key.
12    pub event_key: String,
13    /// Event data.
14    pub event_data: serde_json::Value,
15    /// Event time.
16    pub event_time: DateTime<Utc>,
17    /// Is processed.
18    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)]
39/// Eventsubscription.
40pub struct EventSubscription {
41    /// Id.
42    pub id: String,
43    /// Workflow id.
44    pub workflow_id: String,
45    /// Step id.
46    pub step_id: usize,
47    /// Execution pointer id.
48    pub execution_pointer_id: String,
49    /// Event name.
50    pub event_name: String,
51    /// Event key.
52    pub event_key: String,
53    /// Subscribe as of.
54    pub subscribe_as_of: DateTime<Utc>,
55    /// Subscription data.
56    pub subscription_data: Option<serde_json::Value>,
57    /// External token.
58    pub external_token: Option<String>,
59    /// External worker id.
60    pub external_worker_id: Option<String>,
61    /// External token expiry.
62    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}