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}