qail_workflow_postgres/
executor.rs1use async_trait::async_trait;
2use chrono::{DateTime, Utc};
3use qail_workflow::{
4 ChannelKind, ChargeRequest, ChargeResponse, PaymentKind, WorkflowContext, WorkflowError,
5 WorkflowExecutor, WorkflowLease, WorkflowOperation, WorkflowOperationStatus,
6 WorkflowSideEffect, WorkflowSideEffectStatus,
7};
8
9use crate::store::PgWorkflowStore;
10
11pub struct PgWorkflowExecutor<E> {
14 inner: E,
15 store: PgWorkflowStore,
16}
17
18impl<E> PgWorkflowExecutor<E> {
19 pub fn new(inner: E, store: PgWorkflowStore) -> Self {
21 Self { inner, store }
22 }
23
24 pub fn store(&self) -> &PgWorkflowStore {
26 &self.store
27 }
28
29 pub fn inner(&self) -> &E {
31 &self.inner
32 }
33}
34
35#[async_trait]
36impl<E> WorkflowExecutor for PgWorkflowExecutor<E>
37where
38 E: WorkflowExecutor,
39{
40 async fn execute_query(&self, cmd_json: &str) -> Result<serde_json::Value, WorkflowError> {
41 self.inner.execute_query(cmd_json).await
42 }
43
44 async fn send_notification(
45 &self,
46 channel: &ChannelKind,
47 recipient: &str,
48 template: &str,
49 params: &serde_json::Value,
50 ) -> Result<(), WorkflowError> {
51 self.inner
52 .send_notification(channel, recipient, template, params)
53 .await
54 }
55
56 async fn save_state(&self, ctx: &WorkflowContext) -> Result<(), WorkflowError> {
57 self.store.save_state(ctx).await
58 }
59
60 async fn load_state(
61 &self,
62 workflow_id: &str,
63 ) -> Result<Option<WorkflowContext>, WorkflowError> {
64 self.store.load_state(workflow_id).await
65 }
66
67 async fn create_charge(
68 &self,
69 provider: &PaymentKind,
70 request: ChargeRequest,
71 ) -> Result<ChargeResponse, WorkflowError> {
72 self.inner.create_charge(provider, request).await
73 }
74
75 async fn acquire_workflow_lease(&self, lease: &WorkflowLease) -> Result<bool, WorkflowError> {
76 self.store.acquire_workflow_lease(lease).await
77 }
78
79 async fn release_workflow_lease(&self, lease: &WorkflowLease) -> Result<(), WorkflowError> {
80 self.store.release_workflow_lease(lease).await
81 }
82
83 async fn begin_workflow_operation(
84 &self,
85 operation: &WorkflowOperation,
86 ) -> Result<WorkflowOperationStatus, WorkflowError> {
87 self.store.begin_workflow_operation(operation).await
88 }
89
90 async fn complete_workflow_operation(
91 &self,
92 operation: &WorkflowOperation,
93 state: &str,
94 ) -> Result<(), WorkflowError> {
95 self.store
96 .complete_workflow_operation(operation, state)
97 .await
98 }
99
100 async fn fail_workflow_operation(
101 &self,
102 operation: &WorkflowOperation,
103 error: &str,
104 ) -> Result<(), WorkflowError> {
105 self.store.fail_workflow_operation(operation, error).await
106 }
107
108 async fn load_due_workflow_timeouts(
109 &self,
110 workflow_name: &str,
111 now: DateTime<Utc>,
112 limit: usize,
113 ) -> Result<Vec<String>, WorkflowError> {
114 self.store
115 .load_due_workflow_timeouts(workflow_name, now, limit)
116 .await
117 }
118
119 async fn begin_workflow_side_effect(
120 &self,
121 operation: &WorkflowSideEffect,
122 ) -> Result<WorkflowSideEffectStatus, WorkflowError> {
123 self.store.begin_workflow_side_effect(operation).await
124 }
125
126 async fn complete_workflow_side_effect(
127 &self,
128 operation: &WorkflowSideEffect,
129 result: Option<&serde_json::Value>,
130 ) -> Result<(), WorkflowError> {
131 self.store
132 .complete_workflow_side_effect(operation, result)
133 .await
134 }
135
136 async fn fail_workflow_side_effect(
137 &self,
138 operation: &WorkflowSideEffect,
139 error: &str,
140 ) -> Result<(), WorkflowError> {
141 self.store.fail_workflow_side_effect(operation, error).await
142 }
143}