1use serde::{Deserialize, Serialize};
2use serde_json::Value;
3use uuid::Uuid;
4
5#[derive(Debug, Clone, Serialize, Deserialize)]
6#[serde(tag = "type", rename_all = "lowercase")]
7pub enum Message {
8 RegisterTriggerType {
9 id: String,
10 description: String,
11 },
12 RegisterTrigger {
13 id: String,
14 trigger_type: String,
15 function_id: String,
16 config: Value,
17 },
18 TriggerRegistrationResult {
19 id: String,
20 trigger_type: String,
21 function_id: String,
22 #[serde(skip_serializing_if = "Option::is_none")]
23 error: Option<ErrorBody>,
24 },
25 UnregisterTrigger {
26 id: String,
27 trigger_type: String,
28 },
29 RegisterFunction {
30 id: String,
31 #[serde(skip_serializing_if = "Option::is_none")]
32 description: Option<String>,
33 #[serde(skip_serializing_if = "Option::is_none")]
34 request_format: Option<Value>,
35 #[serde(skip_serializing_if = "Option::is_none")]
36 response_format: Option<Value>,
37 #[serde(skip_serializing_if = "Option::is_none")]
38 metadata: Option<Value>,
39 },
40 InvokeFunction {
41 invocation_id: Option<Uuid>,
42 function_id: String,
43 data: Value,
44 #[serde(skip_serializing_if = "Option::is_none")]
45 traceparent: Option<String>,
46 #[serde(skip_serializing_if = "Option::is_none")]
47 baggage: Option<String>,
48 },
49 InvocationResult {
50 invocation_id: Uuid,
51 function_id: String,
52 #[serde(skip_serializing_if = "Option::is_none")]
53 result: Option<Value>,
54 #[serde(skip_serializing_if = "Option::is_none")]
55 error: Option<ErrorBody>,
56 #[serde(skip_serializing_if = "Option::is_none")]
57 traceparent: Option<String>,
58 #[serde(skip_serializing_if = "Option::is_none")]
59 baggage: Option<String>,
60 },
61 RegisterService {
62 id: String,
63 name: String,
64 #[serde(skip_serializing_if = "Option::is_none")]
65 description: Option<String>,
66 },
67 Ping,
68 Pong,
69 WorkerRegistered {
70 worker_id: String,
71 },
72}
73
74#[derive(Debug, Clone, Serialize, Deserialize)]
75pub struct RegisterTriggerTypeMessage {
76 pub id: String,
77 pub description: String,
78}
79
80impl RegisterTriggerTypeMessage {
81 pub fn to_message(&self) -> Message {
82 Message::RegisterTriggerType {
83 id: self.id.clone(),
84 description: self.description.clone(),
85 }
86 }
87}
88
89#[derive(Debug, Clone, Serialize, Deserialize)]
90pub struct RegisterTriggerMessage {
91 pub id: String,
92 pub trigger_type: String,
93 pub function_id: String,
94 pub config: Value,
95}
96
97impl RegisterTriggerMessage {
98 pub fn to_message(&self) -> Message {
99 Message::RegisterTrigger {
100 id: self.id.clone(),
101 trigger_type: self.trigger_type.clone(),
102 function_id: self.function_id.clone(),
103 config: self.config.clone(),
104 }
105 }
106}
107
108#[derive(Debug, Clone, Serialize, Deserialize)]
109pub struct UnregisterTriggerMessage {
110 pub id: String,
111 pub trigger_type: String,
112}
113
114impl UnregisterTriggerMessage {
115 pub fn to_message(&self) -> Message {
116 Message::UnregisterTrigger {
117 id: self.id.clone(),
118 trigger_type: self.trigger_type.clone(),
119 }
120 }
121}
122
123#[derive(Debug, Clone, Serialize, Deserialize)]
124pub struct RegisterFunctionMessage {
125 pub id: String,
126 #[serde(skip_serializing_if = "Option::is_none")]
127 pub description: Option<String>,
128 #[serde(skip_serializing_if = "Option::is_none")]
129 pub request_format: Option<Value>,
130 #[serde(skip_serializing_if = "Option::is_none")]
131 pub response_format: Option<Value>,
132 #[serde(skip_serializing_if = "Option::is_none")]
133 pub metadata: Option<Value>,
134}
135
136impl RegisterFunctionMessage {
137 pub fn to_message(&self) -> Message {
138 Message::RegisterFunction {
139 id: self.id.clone(),
140 description: self.description.clone(),
141 request_format: self.request_format.clone(),
142 response_format: self.response_format.clone(),
143 metadata: self.metadata.clone(),
144 }
145 }
146}
147
148#[derive(Debug, Clone, Serialize, Deserialize)]
149pub struct RegisterServiceMessage {
150 pub id: String,
151 pub name: String,
152 #[serde(skip_serializing_if = "Option::is_none")]
153 pub description: Option<String>,
154}
155
156impl RegisterServiceMessage {
157 pub fn to_message(&self) -> Message {
158 Message::RegisterService {
159 id: self.id.clone(),
160 name: self.name.clone(),
161 description: self.description.clone(),
162 }
163 }
164}
165
166#[derive(Debug, Clone, Serialize, Deserialize)]
167pub struct FunctionMessage {
168 pub function_id: String,
169 #[serde(skip_serializing_if = "Option::is_none")]
170 pub description: Option<String>,
171 #[serde(skip_serializing_if = "Option::is_none")]
172 pub request_format: Option<Value>,
173 #[serde(skip_serializing_if = "Option::is_none")]
174 pub response_format: Option<Value>,
175 #[serde(skip_serializing_if = "Option::is_none")]
176 pub metadata: Option<Value>,
177}
178
179#[derive(Debug, Clone, Serialize, Deserialize)]
180pub struct ErrorBody {
181 pub code: String,
182 pub message: String,
183}
184
185#[cfg(test)]
186mod tests {
187 use super::*;
188
189 #[test]
190 fn register_function_to_message_and_serializes_type() {
191 let msg = RegisterFunctionMessage {
192 id: "functions.echo".to_string(),
193 description: Some("Echo function".to_string()),
194 request_format: None,
195 response_format: None,
196 metadata: None,
197 };
198
199 let message = msg.to_message();
200 match &message {
201 Message::RegisterFunction {
202 id, description, ..
203 } => {
204 assert_eq!(id, "functions.echo");
205 assert_eq!(description.as_deref(), Some("Echo function"));
206 }
207 _ => panic!("unexpected message variant"),
208 }
209
210 let serialized = serde_json::to_value(&message).unwrap();
211 assert_eq!(serialized["type"], "registerfunction");
212 assert_eq!(serialized["id"], "functions.echo");
213 assert_eq!(serialized["description"], "Echo function");
214 }
215}