lash_remote_protocol/protocol/
triggers.rs

1#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, JsonSchema)]
2pub struct RemoteTriggerOccurrenceRequest {
3    pub protocol_version: u32,
4    pub source_type: String,
5    pub source_key: String,
6    #[serde(default)]
7    pub payload: serde_json::Value,
8    pub idempotency_key: String,
9    #[serde(default, skip_serializing_if = "Option::is_none")]
10    pub source: Option<serde_json::Value>,
11}
12
13impl RemoteTriggerOccurrenceRequest {
14    pub fn new(
15        source_type: impl Into<String>,
16        source_key: impl Into<String>,
17        payload: serde_json::Value,
18        idempotency_key: impl Into<String>,
19    ) -> Self {
20        Self {
21            protocol_version: REMOTE_PROTOCOL_VERSION,
22            source_type: source_type.into(),
23            source_key: source_key.into(),
24            payload,
25            idempotency_key: idempotency_key.into(),
26            source: None,
27        }
28    }
29
30    pub fn with_source(mut self, source: serde_json::Value) -> Self {
31        self.source = Some(source);
32        self
33    }
34
35    pub fn validate(&self) -> Result<(), RemoteProtocolError> {
36        ensure_protocol_version(self.protocol_version)?;
37        require_non_empty(
38            "RemoteTriggerOccurrenceRequest",
39            "source_type",
40            &self.source_type,
41        )?;
42        require_non_empty(
43            "RemoteTriggerOccurrenceRequest",
44            "source_key",
45            &self.source_key,
46        )?;
47        require_non_empty(
48            "RemoteTriggerOccurrenceRequest",
49            "idempotency_key",
50            &self.idempotency_key,
51        )
52    }
53}
54
55#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, JsonSchema)]
56pub struct RemoteTriggerOccurrenceRecord {
57    pub occurrence_id: String,
58    pub source_type: String,
59    pub source_key: String,
60    #[serde(default)]
61    pub payload: serde_json::Value,
62    pub idempotency_key: String,
63    #[serde(default, skip_serializing_if = "Option::is_none")]
64    pub source: Option<serde_json::Value>,
65    pub occurred_at_ms: u64,
66}
67
68#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
69pub struct RemoteTriggerEmitReport {
70    pub protocol_version: u32,
71    #[serde(default, skip_serializing_if = "String::is_empty")]
72    pub occurrence_id: String,
73    #[serde(default, skip_serializing_if = "Vec::is_empty")]
74    pub started_process_ids: Vec<String>,
75}
76
77impl RemoteTriggerEmitReport {
78    pub fn validate(&self) -> Result<(), RemoteProtocolError> {
79        ensure_protocol_version(self.protocol_version)
80    }
81}
82
83#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, JsonSchema)]
84pub struct RemoteTriggerSubscriptionFilter {
85    pub protocol_version: u32,
86    #[serde(default, skip_serializing_if = "Option::is_none")]
87    pub session_id: Option<String>,
88    #[serde(default, skip_serializing_if = "Option::is_none")]
89    pub handle: Option<String>,
90    #[serde(default, skip_serializing_if = "Option::is_none")]
91    pub name: Option<String>,
92    #[serde(default, skip_serializing_if = "Option::is_none")]
93    pub source_type: Option<String>,
94    #[serde(default, skip_serializing_if = "Option::is_none")]
95    pub source_key: Option<String>,
96    #[serde(default, skip_serializing_if = "Option::is_none")]
97    pub target: Option<RemoteProcessDefinitionIdentity>,
98    #[serde(default, skip_serializing_if = "Option::is_none")]
99    pub enabled: Option<bool>,
100}
101
102impl Default for RemoteTriggerSubscriptionFilter {
103    fn default() -> Self {
104        Self {
105            protocol_version: REMOTE_PROTOCOL_VERSION,
106            session_id: None,
107            handle: None,
108            name: None,
109            source_type: None,
110            source_key: None,
111            target: None,
112            enabled: None,
113        }
114    }
115}
116
117impl RemoteTriggerSubscriptionFilter {
118    pub fn for_session(session_id: impl Into<String>) -> Self {
119        Self {
120            protocol_version: REMOTE_PROTOCOL_VERSION,
121            session_id: Some(session_id.into()),
122            ..Self::default()
123        }
124    }
125
126    pub fn for_source_type(source_type: impl Into<String>) -> Self {
127        Self {
128            protocol_version: REMOTE_PROTOCOL_VERSION,
129            source_type: Some(source_type.into()),
130            ..Self::default()
131        }
132    }
133
134    pub fn validate(&self) -> Result<(), RemoteProtocolError> {
135        ensure_protocol_version(self.protocol_version)
136    }
137}
138
139#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, JsonSchema)]
140pub struct RemoteTriggerRegistration {
141    pub handle: String,
142    pub source_key: String,
143    #[serde(default, skip_serializing_if = "Option::is_none")]
144    pub name: Option<String>,
145    pub source_type: String,
146    #[serde(default)]
147    pub source: serde_json::Value,
148    pub target: RemoteTriggerTargetSummary,
149    #[serde(default = "default_true")]
150    pub enabled: bool,
151}
152
153#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, JsonSchema)]
154pub struct RemoteTriggerTargetSummary {
155    #[serde(default, skip_serializing_if = "Option::is_none")]
156    pub label: Option<String>,
157    pub identity: RemoteProcessIdentity,
158    pub input: RemoteProcessInput,
159    #[serde(default)]
160    pub inputs: RemoteTriggerInputTemplate,
161}
162
163fn default_true() -> bool {
164    true
165}
166
167#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, JsonSchema)]
168#[serde(transparent)]
169pub struct RemoteTriggerInputTemplate {
170    pub entries: BTreeMap<String, RemoteTriggerInputBinding>,
171}
172
173impl RemoteTriggerInputTemplate {
174    pub fn new(entries: BTreeMap<String, RemoteTriggerInputBinding>) -> Self {
175        Self { entries }
176    }
177
178    pub fn validate(&self, type_name: &'static str) -> Result<(), RemoteProtocolError> {
179        for name in self.entries.keys() {
180            require_non_empty(type_name, "input_template key", name)?;
181        }
182        Ok(())
183    }
184}
185
186#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, JsonSchema)]
187#[serde(tag = "kind", rename_all = "snake_case")]
188pub enum RemoteTriggerInputBinding {
189    Event,
190    Fixed { value: serde_json::Value },
191}
192
193#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, JsonSchema)]
194pub struct RemoteTriggerSubscriptionDraft {
195    pub protocol_version: u32,
196    pub registrant: RemoteProcessOriginator,
197    pub env_ref: String,
198    #[serde(default, skip_serializing_if = "Option::is_none")]
199    pub wake_target: Option<RemoteSessionScope>,
200    #[serde(default, skip_serializing_if = "Option::is_none")]
201    pub name: Option<String>,
202    pub source_type: String,
203    pub source_key: String,
204    #[serde(default)]
205    pub source: serde_json::Value,
206    #[serde(default)]
207    pub payload_schema: serde_json::Value,
208    pub target: RemoteProcessInput,
209    pub target_identity: RemoteProcessIdentity,
210    #[serde(default, skip_serializing_if = "Vec::is_empty")]
211    pub event_types: Vec<RemoteProcessEventType>,
212    #[serde(default)]
213    pub input_template: RemoteTriggerInputTemplate,
214    #[serde(default, skip_serializing_if = "Option::is_none")]
215    pub target_label: Option<String>,
216}
217
218impl RemoteTriggerSubscriptionDraft {
219    pub fn validate(&self) -> Result<(), RemoteProtocolError> {
220        ensure_protocol_version(self.protocol_version)?;
221        self.registrant.validate("RemoteTriggerSubscriptionDraft")?;
222        require_non_empty("RemoteTriggerSubscriptionDraft", "env_ref", &self.env_ref)?;
223        if let Some(wake_target) = &self.wake_target {
224            wake_target.validate("RemoteTriggerSubscriptionDraft")?;
225        }
226        require_non_empty(
227            "RemoteTriggerSubscriptionDraft",
228            "source_type",
229            &self.source_type,
230        )?;
231        require_non_empty(
232            "RemoteTriggerSubscriptionDraft",
233            "source_key",
234            &self.source_key,
235        )?;
236        self.target.validate("RemoteTriggerSubscriptionDraft")?;
237        self.target_identity
238            .validate("RemoteTriggerSubscriptionDraft")?;
239        for event_type in &self.event_types {
240            event_type.validate("RemoteTriggerSubscriptionDraft")?;
241        }
242        self.input_template
243            .validate("RemoteTriggerSubscriptionDraft")
244    }
245}
246
247#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, JsonSchema)]
248pub struct RemoteTriggerSubscriptionRecord {
249    pub subscription_id: String,
250    pub registrant: RemoteProcessOriginator,
251    pub env_ref: String,
252    #[serde(default, skip_serializing_if = "Option::is_none")]
253    pub wake_target: Option<RemoteSessionScope>,
254    pub handle: String,
255    #[serde(default, skip_serializing_if = "Option::is_none")]
256    pub name: Option<String>,
257    pub source_type: String,
258    pub source_key: String,
259    #[serde(default)]
260    pub source: serde_json::Value,
261    #[serde(default)]
262    pub payload_schema: serde_json::Value,
263    pub target: RemoteProcessInput,
264    pub target_identity: RemoteProcessIdentity,
265    #[serde(default, skip_serializing_if = "Vec::is_empty")]
266    pub event_types: Vec<RemoteProcessEventType>,
267    #[serde(default)]
268    pub input_template: RemoteTriggerInputTemplate,
269    #[serde(default, skip_serializing_if = "Option::is_none")]
270    pub target_label: Option<String>,
271    #[serde(default = "default_true")]
272    pub enabled: bool,
273    pub created_at_ms: u64,
274    pub updated_at_ms: u64,
275}
276
277impl RemoteTriggerSubscriptionRecord {
278    pub fn validate(&self, type_name: &'static str) -> Result<(), RemoteProtocolError> {
279        require_non_empty(type_name, "subscription_id", &self.subscription_id)?;
280        self.registrant.validate(type_name)?;
281        require_non_empty(type_name, "env_ref", &self.env_ref)?;
282        if let Some(wake_target) = &self.wake_target {
283            wake_target.validate(type_name)?;
284        }
285        require_non_empty(type_name, "handle", &self.handle)?;
286        require_non_empty(type_name, "source_type", &self.source_type)?;
287        require_non_empty(type_name, "source_key", &self.source_key)?;
288        self.target.validate(type_name)?;
289        self.target_identity.validate(type_name)?;
290        for event_type in &self.event_types {
291            event_type.validate(type_name)?;
292        }
293        self.input_template.validate(type_name)
294    }
295}
296
297#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, JsonSchema)]
298pub struct RemoteTriggerRegisterSubscriptionRequest {
299    pub protocol_version: u32,
300    pub draft: RemoteTriggerSubscriptionDraft,
301}
302
303impl RemoteTriggerRegisterSubscriptionRequest {
304    pub fn validate(&self) -> Result<(), RemoteProtocolError> {
305        ensure_protocol_version(self.protocol_version)?;
306        if self.draft.protocol_version != self.protocol_version {
307            return Err(RemoteProtocolError::MismatchedNestedProtocolVersion {
308                parent: "RemoteTriggerRegisterSubscriptionRequest",
309                child: "draft",
310                parent_version: self.protocol_version,
311                child_version: self.draft.protocol_version,
312            });
313        }
314        self.draft.validate()
315    }
316}
317
318#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, JsonSchema)]
319pub struct RemoteTriggerRegisterSubscriptionResult {
320    pub protocol_version: u32,
321    pub record: RemoteTriggerSubscriptionRecord,
322}
323
324impl RemoteTriggerRegisterSubscriptionResult {
325    pub fn validate(&self) -> Result<(), RemoteProtocolError> {
326        ensure_protocol_version(self.protocol_version)?;
327        self.record
328            .validate("RemoteTriggerRegisterSubscriptionResult")
329    }
330}
331
332#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, JsonSchema)]
333pub struct RemoteTriggerListSubscriptionsResponse {
334    pub protocol_version: u32,
335    #[serde(default)]
336    pub subscriptions: Vec<RemoteTriggerSubscriptionRecord>,
337}
338
339impl RemoteTriggerListSubscriptionsResponse {
340    pub fn validate(&self) -> Result<(), RemoteProtocolError> {
341        ensure_protocol_version(self.protocol_version)?;
342        for record in &self.subscriptions {
343            record.validate("RemoteTriggerListSubscriptionsResponse")?;
344        }
345        Ok(())
346    }
347}
348
349#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
350pub struct RemoteTriggerCancelSubscriptionRequest {
351    pub protocol_version: u32,
352    pub session_id: String,
353    pub handle: String,
354}
355
356impl RemoteTriggerCancelSubscriptionRequest {
357    pub fn validate(&self) -> Result<(), RemoteProtocolError> {
358        ensure_protocol_version(self.protocol_version)?;
359        require_non_empty(
360            "RemoteTriggerCancelSubscriptionRequest",
361            "session_id",
362            &self.session_id,
363        )?;
364        require_non_empty(
365            "RemoteTriggerCancelSubscriptionRequest",
366            "handle",
367            &self.handle,
368        )
369    }
370}
371
372#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
373pub struct RemoteTriggerCancelSubscriptionResult {
374    pub protocol_version: u32,
375    pub session_id: String,
376    pub handle: String,
377    pub cancelled: bool,
378}
379
380impl RemoteTriggerCancelSubscriptionResult {
381    pub fn validate(&self) -> Result<(), RemoteProtocolError> {
382        ensure_protocol_version(self.protocol_version)?;
383        require_non_empty(
384            "RemoteTriggerCancelSubscriptionResult",
385            "session_id",
386            &self.session_id,
387        )?;
388        require_non_empty(
389            "RemoteTriggerCancelSubscriptionResult",
390            "handle",
391            &self.handle,
392        )
393    }
394}
lash_remote_protocol/protocol/triggers.rs

lash_remote_protocol/protocol/
triggers.rs
