Skip to main content

khive_db/backend/core_stores/
graph.rs

1use super::super::StorageBackend;
2use super::map_open_error;
3use async_trait::async_trait;
4use chrono::{DateTime, Utc};
5use khive_storage::graph::{GraphStore, SymmetricEdgeUpdateOutcome, SymmetricEdgeUpdateRequest};
6use khive_storage::types::EdgeEndpointBaseCounts;
7use khive_storage::{
8    BatchWriteSummary, DeleteMode, DirectedNeighborHit, Edge, EdgeFilter, EdgeSeekPage,
9    EdgeSortField, EdgeUpsertRequest, EdgeUpsertResult, GraphPath, GuardedBatchOutcome,
10    GuardedEdgeBatchUpsertOutcome, GuardedEdgeUpsertOutcome, GuardedWriteOutcome, LinkId,
11    NeighborCursor, NeighborHit, NeighborQuery, Page, PageRequest, SeekCursor, SeekPage, SortOrder,
12    StorageCapability, StorageResult, TraversalRequest,
13};
14use khive_types::EdgeRelation;
15use uuid::Uuid;
16
17#[async_trait]
18impl GraphStore for StorageBackend {
19    async fn latest_annotating_note(
20        &self,
21        _node_id: Uuid,
22        _kind: &str,
23        _tag: &str,
24    ) -> StorageResult<Option<(Uuid, i64)>> {
25        self.graph()
26            .map_err(|error| map_open_error(error, StorageCapability::Graph, "graph"))?
27            .latest_annotating_note(_node_id, _kind, _tag)
28            .await
29    }
30
31    async fn latest_annotating_note_with_property(
32        &self,
33        _node_id: Uuid,
34        _kind: &str,
35        _tag: &str,
36        _property_key: &str,
37        _property_value: &str,
38    ) -> StorageResult<Option<(Uuid, i64)>> {
39        self.graph()
40            .map_err(|error| map_open_error(error, StorageCapability::Graph, "graph"))?
41            .latest_annotating_note_with_property(
42                _node_id,
43                _kind,
44                _tag,
45                _property_key,
46                _property_value,
47            )
48            .await
49    }
50
51    async fn upsert_edge(&self, edge: Edge) -> StorageResult<()> {
52        self.graph()
53            .map_err(|error| map_open_error(error, StorageCapability::Graph, "graph"))?
54            .upsert_edge(edge)
55            .await
56    }
57
58    async fn insert_edge_if_absent(&self, _edge: Edge) -> StorageResult<bool> {
59        self.graph()
60            .map_err(|error| map_open_error(error, StorageCapability::Graph, "graph"))?
61            .insert_edge_if_absent(_edge)
62            .await
63    }
64
65    async fn upsert_edges(&self, edges: Vec<Edge>) -> StorageResult<BatchWriteSummary> {
66        self.graph()
67            .map_err(|error| map_open_error(error, StorageCapability::Graph, "graph"))?
68            .upsert_edges(edges)
69            .await
70    }
71
72    async fn upsert_edge_observed(
73        &self,
74        _request: EdgeUpsertRequest,
75    ) -> StorageResult<EdgeUpsertResult> {
76        self.graph()
77            .map_err(|error| map_open_error(error, StorageCapability::Graph, "graph"))?
78            .upsert_edge_observed(_request)
79            .await
80    }
81
82    async fn replace_edge_if_unchanged(
83        &self,
84        _edge: Edge,
85        _expected_updated_at: DateTime<Utc>,
86        _expected_deleted_at: Option<DateTime<Utc>>,
87    ) -> StorageResult<bool> {
88        self.graph()
89            .map_err(|error| map_open_error(error, StorageCapability::Graph, "graph"))?
90            .replace_edge_if_unchanged(_edge, _expected_updated_at, _expected_deleted_at)
91            .await
92    }
93
94    async fn update_symmetric_edge_if_unchanged(
95        &self,
96        _request: SymmetricEdgeUpdateRequest,
97    ) -> StorageResult<SymmetricEdgeUpdateOutcome> {
98        self.graph()
99            .map_err(|error| map_open_error(error, StorageCapability::Graph, "graph"))?
100            .update_symmetric_edge_if_unchanged(_request)
101            .await
102    }
103
104    async fn upsert_edge_guarded(&self, _edge: Edge) -> StorageResult<GuardedWriteOutcome> {
105        self.graph()
106            .map_err(|error| map_open_error(error, StorageCapability::Graph, "graph"))?
107            .upsert_edge_guarded(_edge)
108            .await
109    }
110
111    async fn upsert_edge_guarded_observed(
112        &self,
113        _request: EdgeUpsertRequest,
114    ) -> StorageResult<GuardedEdgeUpsertOutcome> {
115        self.graph()
116            .map_err(|error| map_open_error(error, StorageCapability::Graph, "graph"))?
117            .upsert_edge_guarded_observed(_request)
118            .await
119    }
120
121    async fn upsert_edges_guarded(&self, _edges: Vec<Edge>) -> StorageResult<GuardedBatchOutcome> {
122        self.graph()
123            .map_err(|error| map_open_error(error, StorageCapability::Graph, "graph"))?
124            .upsert_edges_guarded(_edges)
125            .await
126    }
127
128    async fn upsert_edges_guarded_observed(
129        &self,
130        _requests: Vec<EdgeUpsertRequest>,
131    ) -> StorageResult<GuardedEdgeBatchUpsertOutcome> {
132        self.graph()
133            .map_err(|error| map_open_error(error, StorageCapability::Graph, "graph"))?
134            .upsert_edges_guarded_observed(_requests)
135            .await
136    }
137
138    async fn get_edge(&self, id: LinkId) -> StorageResult<Option<Edge>> {
139        self.graph()
140            .map_err(|error| map_open_error(error, StorageCapability::Graph, "graph"))?
141            .get_edge(id)
142            .await
143    }
144
145    async fn get_edge_including_deleted(&self, id: LinkId) -> StorageResult<Option<Edge>> {
146        self.graph()
147            .map_err(|error| map_open_error(error, StorageCapability::Graph, "graph"))?
148            .get_edge_including_deleted(id)
149            .await
150    }
151
152    async fn get_edge_by_natural_key_including_deleted(
153        &self,
154        namespace: &str,
155        source_id: Uuid,
156        target_id: Uuid,
157        relation: EdgeRelation,
158    ) -> StorageResult<Option<Edge>> {
159        self.graph()
160            .map_err(|error| map_open_error(error, StorageCapability::Graph, "graph"))?
161            .get_edge_by_natural_key_including_deleted(namespace, source_id, target_id, relation)
162            .await
163    }
164
165    async fn delete_edge(&self, id: LinkId, mode: DeleteMode) -> StorageResult<bool> {
166        self.graph()
167            .map_err(|error| map_open_error(error, StorageCapability::Graph, "graph"))?
168            .delete_edge(id, mode)
169            .await
170    }
171
172    async fn query_edges(
173        &self,
174        filter: EdgeFilter,
175        sort: Vec<SortOrder<EdgeSortField>>,
176        page: PageRequest,
177    ) -> StorageResult<Page<Edge>> {
178        self.graph()
179            .map_err(|error| map_open_error(error, StorageCapability::Graph, "graph"))?
180            .query_edges(filter, sort, page)
181            .await
182    }
183
184    async fn query_edges_in_namespaces(
185        &self,
186        namespaces: &[String],
187        filter: EdgeFilter,
188        sort: Vec<SortOrder<EdgeSortField>>,
189        page: PageRequest,
190    ) -> StorageResult<Page<Edge>> {
191        self.graph()
192            .map_err(|error| map_open_error(error, StorageCapability::Graph, "graph"))?
193            .query_edges_in_namespaces(namespaces, filter, sort, page)
194            .await
195    }
196
197    async fn count_edges(&self, filter: EdgeFilter) -> StorageResult<u64> {
198        self.graph()
199            .map_err(|error| map_open_error(error, StorageCapability::Graph, "graph"))?
200            .count_edges(filter)
201            .await
202    }
203
204    async fn count_edges_in_namespaces(
205        &self,
206        namespaces: &[String],
207        filter: EdgeFilter,
208    ) -> StorageResult<u64> {
209        self.graph()
210            .map_err(|error| map_open_error(error, StorageCapability::Graph, "graph"))?
211            .count_edges_in_namespaces(namespaces, filter)
212            .await
213    }
214
215    async fn count_edges_by_relation(&self) -> StorageResult<Vec<(EdgeRelation, u64)>> {
216        self.graph()
217            .map_err(|error| map_open_error(error, StorageCapability::Graph, "graph"))?
218            .count_edges_by_relation()
219            .await
220    }
221
222    async fn count_edges_by_relation_in_namespaces(
223        &self,
224        namespaces: &[String],
225    ) -> StorageResult<Vec<(EdgeRelation, u64)>> {
226        self.graph()
227            .map_err(|error| map_open_error(error, StorageCapability::Graph, "graph"))?
228            .count_edges_by_relation_in_namespaces(namespaces)
229            .await
230    }
231
232    async fn count_edges_by_endpoint_base(&self) -> StorageResult<EdgeEndpointBaseCounts> {
233        self.graph()
234            .map_err(|error| map_open_error(error, StorageCapability::Graph, "graph"))?
235            .count_edges_by_endpoint_base()
236            .await
237    }
238
239    async fn count_edges_by_endpoint_base_in_namespaces(
240        &self,
241        namespaces: &[String],
242    ) -> StorageResult<EdgeEndpointBaseCounts> {
243        self.graph()
244            .map_err(|error| map_open_error(error, StorageCapability::Graph, "graph"))?
245            .count_edges_by_endpoint_base_in_namespaces(namespaces)
246            .await
247    }
248
249    async fn count_edges_by_relation_and_endpoint_base_in_namespaces(
250        &self,
251        namespaces: &[String],
252    ) -> StorageResult<Vec<(EdgeRelation, EdgeEndpointBaseCounts)>> {
253        self.graph()
254            .map_err(|error| map_open_error(error, StorageCapability::Graph, "graph"))?
255            .count_edges_by_relation_and_endpoint_base_in_namespaces(namespaces)
256            .await
257    }
258
259    async fn query_edges_after(
260        &self,
261        filter: EdgeFilter,
262        after: Option<Uuid>,
263        limit: u32,
264    ) -> StorageResult<EdgeSeekPage> {
265        self.graph()
266            .map_err(|error| map_open_error(error, StorageCapability::Graph, "graph"))?
267            .query_edges_after(filter, after, limit)
268            .await
269    }
270
271    async fn edge_sequence(&self, _id: Uuid) -> StorageResult<Option<i64>> {
272        self.graph()
273            .map_err(|error| map_open_error(error, StorageCapability::Graph, "graph"))?
274            .edge_sequence(_id)
275            .await
276    }
277
278    async fn edge_sequences(&self, ids: &[Uuid]) -> StorageResult<Vec<(Uuid, i64)>> {
279        self.graph()
280            .map_err(|error| map_open_error(error, StorageCapability::Graph, "graph"))?
281            .edge_sequences(ids)
282            .await
283    }
284
285    async fn query_edges_sequence_after(
286        &self,
287        _filter: EdgeFilter,
288        _after: Option<SeekCursor>,
289        _limit: u32,
290    ) -> StorageResult<SeekPage<Edge>> {
291        self.graph()
292            .map_err(|error| map_open_error(error, StorageCapability::Graph, "graph"))?
293            .query_edges_sequence_after(_filter, _after, _limit)
294            .await
295    }
296
297    async fn neighbors(
298        &self,
299        node_id: Uuid,
300        query: NeighborQuery,
301    ) -> StorageResult<Vec<NeighborHit>> {
302        self.graph()
303            .map_err(|error| map_open_error(error, StorageCapability::Graph, "graph"))?
304            .neighbors(node_id, query)
305            .await
306    }
307
308    async fn neighbors_page(
309        &self,
310        node_id: Uuid,
311        query: NeighborQuery,
312        after: Option<NeighborCursor>,
313        neighbor_kinds: Option<Vec<String>>,
314    ) -> StorageResult<Vec<NeighborHit>> {
315        self.graph()
316            .map_err(|error| map_open_error(error, StorageCapability::Graph, "graph"))?
317            .neighbors_page(node_id, query, after, neighbor_kinds)
318            .await
319    }
320
321    async fn neighbors_both_directions(
322        &self,
323        node_id: Uuid,
324        query: NeighborQuery,
325    ) -> StorageResult<Vec<DirectedNeighborHit>> {
326        self.graph()
327            .map_err(|error| map_open_error(error, StorageCapability::Graph, "graph"))?
328            .neighbors_both_directions(node_id, query)
329            .await
330    }
331
332    async fn get_edges(&self, ids: &[LinkId]) -> StorageResult<Vec<Edge>> {
333        self.graph()
334            .map_err(|error| map_open_error(error, StorageCapability::Graph, "graph"))?
335            .get_edges(ids)
336            .await
337    }
338
339    async fn get_edge_read_outcomes(
340        &self,
341        ids: &[LinkId],
342    ) -> StorageResult<Vec<StorageResult<Option<Edge>>>> {
343        self.graph()
344            .map_err(|error| map_open_error(error, StorageCapability::Graph, "graph"))?
345            .get_edge_read_outcomes(ids)
346            .await
347    }
348
349    async fn batch_neighbors(
350        &self,
351        sources: &[Uuid],
352        query: NeighborQuery,
353    ) -> StorageResult<Vec<(Uuid, NeighborHit)>> {
354        self.graph()
355            .map_err(|error| map_open_error(error, StorageCapability::Graph, "graph"))?
356            .batch_neighbors(sources, query)
357            .await
358    }
359
360    async fn traverse(&self, request: TraversalRequest) -> StorageResult<Vec<GraphPath>> {
361        self.graph()
362            .map_err(|error| map_open_error(error, StorageCapability::Graph, "graph"))?
363            .traverse(request)
364            .await
365    }
366
367    async fn purge_incident_edges(&self, node_id: Uuid) -> StorageResult<u64> {
368        self.graph()
369            .map_err(|error| map_open_error(error, StorageCapability::Graph, "graph"))?
370            .purge_incident_edges(node_id)
371            .await
372    }
373}