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}