Skip to main content

qail_workflow_postgres/
executor.rs

1use 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
11/// Workflow executor wrapper that delegates business side effects and stores
12/// runtime guarantees in PostgreSQL.
13pub struct PgWorkflowExecutor<E> {
14    inner: E,
15    store: PgWorkflowStore,
16}
17
18impl<E> PgWorkflowExecutor<E> {
19    /// Wrap an application executor with Postgres-backed workflow storage.
20    pub fn new(inner: E, store: PgWorkflowStore) -> Self {
21        Self { inner, store }
22    }
23
24    /// Return the underlying store.
25    pub fn store(&self) -> &PgWorkflowStore {
26        &self.store
27    }
28
29    /// Return the wrapped application executor.
30    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}