reactive_graph_client/client/instances/flows/
api.rs

1use std::sync::Arc;
2
3use crate::client::ReactiveGraphClient;
4use crate::client::ReactiveGraphClientExecutionError;
5use crate::client::instances::flows::mutations::create_from_type::mutations::create_flow_instance_from_type_mutation;
6use crate::client::instances::flows::mutations::delete::mutations::delete_flow_instance_mutation;
7use crate::client::instances::flows::queries::get_by_id::queries::get_flow_instance_by_id;
8use crate::client::instances::flows::queries::get_by_label::queries::get_flow_instance_by_label;
9use crate::client::instances::flows::queries::search::queries::search;
10use crate::client::instances::flows::variables::search::variables::SearchFlowInstancesVariables;
11use crate::schema_graphql::instances::flow_instance::FlowInstances as FlowInstancesVec;
12
13use cynic::http::ReqwestExt;
14use reactive_graph_graph::FlowInstance;
15use reactive_graph_graph::FlowTypeId;
16use reactive_graph_graph::PropertyInstances;
17use uuid::Uuid;
18
19pub struct FlowInstances {
20    client: Arc<ReactiveGraphClient>,
21}
22
23impl FlowInstances {
24    pub fn new(client: Arc<ReactiveGraphClient>) -> Self {
25        Self { client }
26    }
27
28    pub async fn search(
29        &self,
30        search_query: SearchFlowInstancesVariables,
31    ) -> Result<Option<reactive_graph_graph::FlowInstances>, ReactiveGraphClientExecutionError> {
32        let Some(flow_instances) = self
33            .client
34            .client
35            .post(self.client.url_reactive_graph())
36            .run_graphql(search(search_query))
37            .await
38            .map_err(ReactiveGraphClientExecutionError::FailedToSendRequest)?
39            .data
40            .map(|data| FlowInstancesVec(data.instances.flows))
41        else {
42            return Ok(None);
43        };
44        Ok(Some(
45            reactive_graph_graph::FlowInstances::try_from(flow_instances).map_err(|e| ReactiveGraphClientExecutionError::InvalidFlowInstance(e))?,
46        ))
47    }
48
49    pub async fn get_by_id<ID: Into<Uuid>>(&self, id: ID) -> Result<Option<FlowInstance>, ReactiveGraphClientExecutionError> {
50        let id = id.into();
51        let Some(flow_instance) = self
52            .client
53            .client
54            .post(self.client.url_reactive_graph())
55            .run_graphql(get_flow_instance_by_id(id))
56            .await
57            .map_err(ReactiveGraphClientExecutionError::FailedToSendRequest)?
58            .data
59            .and_then(|data| data.instances.flows.first().cloned())
60        else {
61            return Ok(None);
62        };
63        Ok(Some(
64            reactive_graph_graph::FlowInstance::try_from(flow_instance).map_err(|e| ReactiveGraphClientExecutionError::InvalidFlowInstance(e))?,
65        ))
66    }
67
68    pub async fn get_by_label<L: Into<String>>(&self, label: L) -> Result<Option<FlowInstance>, ReactiveGraphClientExecutionError> {
69        let label = label.into();
70        let Some(flow_instance) = self
71            .client
72            .client
73            .post(self.client.url_reactive_graph())
74            .run_graphql(get_flow_instance_by_label(label))
75            .await
76            .map_err(ReactiveGraphClientExecutionError::FailedToSendRequest)?
77            .data
78            .and_then(|data| data.instances.flows.first().cloned())
79        else {
80            return Ok(None);
81        };
82        Ok(Some(
83            reactive_graph_graph::FlowInstance::try_from(flow_instance).map_err(|e| ReactiveGraphClientExecutionError::InvalidFlowInstance(e))?,
84        ))
85    }
86
87    // TODO: pub async fn create()
88
89    pub async fn create_from_type<TY: Into<FlowTypeId>, ID: Into<Uuid>>(
90        &self,
91        ty: TY,
92        id: Option<ID>,
93        variables: PropertyInstances,
94        properties: PropertyInstances,
95    ) -> Result<Option<FlowInstance>, ReactiveGraphClientExecutionError> {
96        let ty = ty.into();
97        let id = id.map(|id| id.into());
98        let Some(flow_instance) = self
99            .client
100            .client
101            .post(self.client.url_reactive_graph())
102            .run_graphql(create_flow_instance_from_type_mutation(ty, id, variables, properties))
103            .await
104            .map_err(ReactiveGraphClientExecutionError::FailedToSendRequest)?
105            .data
106            .map(|data| data.instances.flows.create_from_type)
107        else {
108            return Ok(None);
109        };
110        Ok(Some(
111            reactive_graph_graph::FlowInstance::try_from(flow_instance).map_err(|e| ReactiveGraphClientExecutionError::InvalidFlowInstance(e))?,
112        ))
113    }
114
115    pub async fn delete<ID: Into<Uuid>>(&self, id: ID) -> Result<Option<bool>, ReactiveGraphClientExecutionError> {
116        let id = id.into();
117        let success = self
118            .client
119            .client
120            .post(self.client.url_reactive_graph())
121            .run_graphql(delete_flow_instance_mutation(id))
122            .await
123            .map_err(ReactiveGraphClientExecutionError::FailedToSendRequest)?
124            .data
125            .map(|data| data.instances.flows.delete);
126        Ok(success)
127    }
128}