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_hidden_incoming_memory_edges(
216        &self,
217        target_ids: &[String],
218        relations: Option<&[String]>,
219        visible_namespaces: &[String],
220    ) -> StorageResult<Vec<(String, String, u64)>> {
221        self.graph()
222            .map_err(|error| map_open_error(error, StorageCapability::Graph, "graph"))?
223            .count_hidden_incoming_memory_edges(target_ids, relations, visible_namespaces)
224            .await
225    }
226
227    async fn count_edges_by_relation(&self) -> StorageResult<Vec<(EdgeRelation, u64)>> {
228        self.graph()
229            .map_err(|error| map_open_error(error, StorageCapability::Graph, "graph"))?
230            .count_edges_by_relation()
231            .await
232    }
233
234    async fn count_edges_by_relation_in_namespaces(
235        &self,
236        namespaces: &[String],
237    ) -> StorageResult<Vec<(EdgeRelation, u64)>> {
238        self.graph()
239            .map_err(|error| map_open_error(error, StorageCapability::Graph, "graph"))?
240            .count_edges_by_relation_in_namespaces(namespaces)
241            .await
242    }
243
244    async fn count_edges_by_endpoint_base(&self) -> StorageResult<EdgeEndpointBaseCounts> {
245        self.graph()
246            .map_err(|error| map_open_error(error, StorageCapability::Graph, "graph"))?
247            .count_edges_by_endpoint_base()
248            .await
249    }
250
251    async fn count_edges_by_endpoint_base_in_namespaces(
252        &self,
253        namespaces: &[String],
254    ) -> StorageResult<EdgeEndpointBaseCounts> {
255        self.graph()
256            .map_err(|error| map_open_error(error, StorageCapability::Graph, "graph"))?
257            .count_edges_by_endpoint_base_in_namespaces(namespaces)
258            .await
259    }
260
261    async fn count_edges_by_relation_and_endpoint_base_in_namespaces(
262        &self,
263        namespaces: &[String],
264    ) -> StorageResult<Vec<(EdgeRelation, EdgeEndpointBaseCounts)>> {
265        self.graph()
266            .map_err(|error| map_open_error(error, StorageCapability::Graph, "graph"))?
267            .count_edges_by_relation_and_endpoint_base_in_namespaces(namespaces)
268            .await
269    }
270
271    async fn query_edges_after(
272        &self,
273        filter: EdgeFilter,
274        after: Option<Uuid>,
275        limit: u32,
276    ) -> StorageResult<EdgeSeekPage> {
277        self.graph()
278            .map_err(|error| map_open_error(error, StorageCapability::Graph, "graph"))?
279            .query_edges_after(filter, after, limit)
280            .await
281    }
282
283    async fn edge_sequence(&self, _id: Uuid) -> StorageResult<Option<i64>> {
284        self.graph()
285            .map_err(|error| map_open_error(error, StorageCapability::Graph, "graph"))?
286            .edge_sequence(_id)
287            .await
288    }
289
290    async fn edge_sequences(&self, ids: &[Uuid]) -> StorageResult<Vec<(Uuid, i64)>> {
291        self.graph()
292            .map_err(|error| map_open_error(error, StorageCapability::Graph, "graph"))?
293            .edge_sequences(ids)
294            .await
295    }
296
297    async fn query_edges_sequence_after(
298        &self,
299        _filter: EdgeFilter,
300        _after: Option<SeekCursor>,
301        _limit: u32,
302    ) -> StorageResult<SeekPage<Edge>> {
303        self.graph()
304            .map_err(|error| map_open_error(error, StorageCapability::Graph, "graph"))?
305            .query_edges_sequence_after(_filter, _after, _limit)
306            .await
307    }
308
309    async fn neighbors(
310        &self,
311        node_id: Uuid,
312        query: NeighborQuery,
313    ) -> StorageResult<Vec<NeighborHit>> {
314        self.graph()
315            .map_err(|error| map_open_error(error, StorageCapability::Graph, "graph"))?
316            .neighbors(node_id, query)
317            .await
318    }
319
320    async fn neighbors_page(
321        &self,
322        node_id: Uuid,
323        query: NeighborQuery,
324        after: Option<NeighborCursor>,
325        neighbor_kinds: Option<Vec<String>>,
326    ) -> StorageResult<Vec<NeighborHit>> {
327        self.graph()
328            .map_err(|error| map_open_error(error, StorageCapability::Graph, "graph"))?
329            .neighbors_page(node_id, query, after, neighbor_kinds)
330            .await
331    }
332
333    async fn neighbors_both_directions(
334        &self,
335        node_id: Uuid,
336        query: NeighborQuery,
337    ) -> StorageResult<Vec<DirectedNeighborHit>> {
338        self.graph()
339            .map_err(|error| map_open_error(error, StorageCapability::Graph, "graph"))?
340            .neighbors_both_directions(node_id, query)
341            .await
342    }
343
344    async fn get_edges(&self, ids: &[LinkId]) -> StorageResult<Vec<Edge>> {
345        self.graph()
346            .map_err(|error| map_open_error(error, StorageCapability::Graph, "graph"))?
347            .get_edges(ids)
348            .await
349    }
350
351    async fn get_edge_read_outcomes(
352        &self,
353        ids: &[LinkId],
354    ) -> StorageResult<Vec<StorageResult<Option<Edge>>>> {
355        self.graph()
356            .map_err(|error| map_open_error(error, StorageCapability::Graph, "graph"))?
357            .get_edge_read_outcomes(ids)
358            .await
359    }
360
361    async fn batch_neighbors(
362        &self,
363        sources: &[Uuid],
364        query: NeighborQuery,
365    ) -> StorageResult<Vec<(Uuid, NeighborHit)>> {
366        self.graph()
367            .map_err(|error| map_open_error(error, StorageCapability::Graph, "graph"))?
368            .batch_neighbors(sources, query)
369            .await
370    }
371
372    async fn traverse(&self, request: TraversalRequest) -> StorageResult<Vec<GraphPath>> {
373        self.graph()
374            .map_err(|error| map_open_error(error, StorageCapability::Graph, "graph"))?
375            .traverse(request)
376            .await
377    }
378
379    async fn purge_incident_edges(&self, node_id: Uuid) -> StorageResult<u64> {
380        self.graph()
381            .map_err(|error| map_open_error(error, StorageCapability::Graph, "graph"))?
382            .purge_incident_edges(node_id)
383            .await
384    }
385}