1use super::super::StorageBackend;
2use super::map_open_error;
3use async_trait::async_trait;
4use khive_storage::note::{
5 validate_note_key_for_store, Note, NoteFilter, NoteKeyAssignOutcome, NoteKeyCursor,
6 NotePropertyPatch, NoteStore, NoteVisibility,
7};
8use khive_storage::{
9 BatchWriteSummary, BoundedCount, DeleteMode, Page, PageRequest, SeekCursor, SeekPage,
10 StorageCapability, StorageResult,
11};
12use serde_json::Value;
13use uuid::Uuid;
14
15#[async_trait]
16impl NoteStore for StorageBackend {
17 async fn assign_note_key_if_unset(
18 &self,
19 id: Uuid,
20 key: &str,
21 namespace: &str,
22 ) -> StorageResult<NoteKeyAssignOutcome> {
23 validate_note_key_for_store(key, "assign_note_key_if_unset")?;
24 self.notes()
25 .map_err(|error| map_open_error(error, StorageCapability::Notes, "notes"))?
26 .assign_note_key_if_unset(id, key, namespace)
27 .await
28 }
29
30 async fn get_live_notes_by_key(
31 &self,
32 _namespace: &str,
33 _key: &str,
34 _kind: Option<&str>,
35 ) -> StorageResult<Vec<Note>> {
36 self.notes()
37 .map_err(|error| map_open_error(error, StorageCapability::Notes, "notes"))?
38 .get_live_notes_by_key(_namespace, _key, _kind)
39 .await
40 }
41
42 async fn query_keyed_notes(
43 &self,
44 _namespace: &str,
45 _filter: &NoteFilter,
46 _prefix: &str,
47 _after: Option<&NoteKeyCursor>,
48 _page: PageRequest,
49 ) -> StorageResult<(Vec<Note>, Option<NoteKeyCursor>)> {
50 self.notes()
51 .map_err(|error| map_open_error(error, StorageCapability::Notes, "notes"))?
52 .query_keyed_notes(_namespace, _filter, _prefix, _after, _page)
53 .await
54 }
55
56 async fn upsert_note(&self, note: Note) -> StorageResult<()> {
57 self.notes()
58 .map_err(|error| map_open_error(error, StorageCapability::Notes, "notes"))?
59 .upsert_note(note)
60 .await
61 }
62
63 async fn replace_note_if_unchanged(
64 &self,
65 _note: Note,
66 _expected_updated_at: i64,
67 _expected_deleted_at: Option<i64>,
68 ) -> StorageResult<bool> {
69 self.notes()
70 .map_err(|error| map_open_error(error, StorageCapability::Notes, "notes"))?
71 .replace_note_if_unchanged(_note, _expected_updated_at, _expected_deleted_at)
72 .await
73 }
74
75 async fn insert_note_if_absent(&self, _note: Note) -> StorageResult<bool> {
76 self.notes()
77 .map_err(|error| map_open_error(error, StorageCapability::Notes, "notes"))?
78 .insert_note_if_absent(_note)
79 .await
80 }
81
82 async fn upsert_notes(&self, notes: Vec<Note>) -> StorageResult<BatchWriteSummary> {
83 self.notes()
84 .map_err(|error| map_open_error(error, StorageCapability::Notes, "notes"))?
85 .upsert_notes(notes)
86 .await
87 }
88
89 async fn get_note(&self, id: Uuid) -> StorageResult<Option<Note>> {
90 self.notes()
91 .map_err(|error| map_open_error(error, StorageCapability::Notes, "notes"))?
92 .get_note(id)
93 .await
94 }
95
96 async fn get_note_including_deleted(&self, id: Uuid) -> StorageResult<Option<Note>> {
97 self.notes()
98 .map_err(|error| map_open_error(error, StorageCapability::Notes, "notes"))?
99 .get_note_including_deleted(id)
100 .await
101 }
102
103 async fn delete_note(&self, id: Uuid, mode: DeleteMode) -> StorageResult<bool> {
104 self.notes()
105 .map_err(|error| map_open_error(error, StorageCapability::Notes, "notes"))?
106 .delete_note(id, mode)
107 .await
108 }
109
110 async fn update_note_properties(
111 &self,
112 id: Uuid,
113 properties: Option<Value>,
114 updated_at: i64,
115 ) -> StorageResult<bool> {
116 self.notes()
117 .map_err(|error| map_open_error(error, StorageCapability::Notes, "notes"))?
118 .update_note_properties(id, properties, updated_at)
119 .await
120 }
121
122 async fn set_note_property(
123 &self,
124 id: Uuid,
125 key: &str,
126 value: Value,
127 updated_at: i64,
128 ) -> StorageResult<bool> {
129 self.notes()
130 .map_err(|error| map_open_error(error, StorageCapability::Notes, "notes"))?
131 .set_note_property(id, key, value, updated_at)
132 .await
133 }
134
135 async fn try_patch_note_property(
136 &self,
137 id: Uuid,
138 namespace: &str,
139 filter: &NoteFilter,
140 json_path: &str,
141 value: Value,
142 updated_at: i64,
143 ) -> StorageResult<bool> {
144 self.notes()
145 .map_err(|error| map_open_error(error, StorageCapability::Notes, "notes"))?
146 .try_patch_note_property(id, namespace, filter, json_path, value, updated_at)
147 .await
148 }
149
150 async fn try_patch_note_properties(
151 &self,
152 id: Uuid,
153 namespace: &str,
154 kind: &str,
155 patch: &NotePropertyPatch,
156 ) -> StorageResult<bool> {
157 self.notes()
158 .map_err(|error| map_open_error(error, StorageCapability::Notes, "notes"))?
159 .try_patch_note_properties(id, namespace, kind, patch)
160 .await
161 }
162
163 async fn patch_note_property_atomic(
164 &self,
165 _ids: Vec<Uuid>,
166 _namespace: &str,
167 _filter: &NoteFilter,
168 _json_path: &str,
169 _value: Value,
170 _updated_at: i64,
171 ) -> StorageResult<()> {
172 self.notes()
173 .map_err(|error| map_open_error(error, StorageCapability::Notes, "notes"))?
174 .patch_note_property_atomic(_ids, _namespace, _filter, _json_path, _value, _updated_at)
175 .await
176 }
177
178 async fn query_notes(
179 &self,
180 namespace: &str,
181 kind: Option<&str>,
182 page: PageRequest,
183 ) -> StorageResult<Page<Note>> {
184 self.notes()
185 .map_err(|error| map_open_error(error, StorageCapability::Notes, "notes"))?
186 .query_notes(namespace, kind, page)
187 .await
188 }
189
190 async fn query_notes_count_free(
191 &self,
192 _namespace: &str,
193 _kind: Option<&str>,
194 _page: PageRequest,
195 ) -> StorageResult<Page<Note>> {
196 self.notes()
197 .map_err(|error| map_open_error(error, StorageCapability::Notes, "notes"))?
198 .query_notes_count_free(_namespace, _kind, _page)
199 .await
200 }
201
202 async fn query_notes_filtered(
203 &self,
204 namespace: &str,
205 filter: &NoteFilter,
206 page: PageRequest,
207 ) -> StorageResult<Page<Note>> {
208 self.notes()
209 .map_err(|error| map_open_error(error, StorageCapability::Notes, "notes"))?
210 .query_notes_filtered(namespace, filter, page)
211 .await
212 }
213
214 async fn query_notes_filtered_count_free(
215 &self,
216 _namespace: &str,
217 _filter: &NoteFilter,
218 _page: PageRequest,
219 ) -> StorageResult<Page<Note>> {
220 self.notes()
221 .map_err(|error| map_open_error(error, StorageCapability::Notes, "notes"))?
222 .query_notes_filtered_count_free(_namespace, _filter, _page)
223 .await
224 }
225
226 async fn count_notes_filtered_in_snapshot(
227 &self,
228 _namespace: &str,
229 _filters: &[NoteFilter],
230 ) -> StorageResult<Vec<u64>> {
231 self.notes()
232 .map_err(|error| map_open_error(error, StorageCapability::Notes, "notes"))?
233 .count_notes_filtered_in_snapshot(_namespace, _filters)
234 .await
235 }
236
237 async fn count_notes_filtered_bounded_in_snapshot(
238 &self,
239 _namespace: &str,
240 _filters: &[NoteFilter],
241 _cap: u32,
242 ) -> StorageResult<Vec<BoundedCount>> {
243 self.notes()
244 .map_err(|error| map_open_error(error, StorageCapability::Notes, "notes"))?
245 .count_notes_filtered_bounded_in_snapshot(_namespace, _filters, _cap)
246 .await
247 }
248
249 async fn note_sequence(&self, _id: Uuid) -> StorageResult<Option<i64>> {
250 self.notes()
251 .map_err(|error| map_open_error(error, StorageCapability::Notes, "notes"))?
252 .note_sequence(_id)
253 .await
254 }
255
256 async fn query_notes_filtered_after(
257 &self,
258 _namespace: &str,
259 _filter: &NoteFilter,
260 _after: Option<SeekCursor>,
261 _limit: u32,
262 ) -> StorageResult<SeekPage<Note>> {
263 self.notes()
264 .map_err(|error| map_open_error(error, StorageCapability::Notes, "notes"))?
265 .query_notes_filtered_after(_namespace, _filter, _after, _limit)
266 .await
267 }
268
269 async fn query_notes_filtered_bounded(
270 &self,
271 namespace: &str,
272 filter: &NoteFilter,
273 max_rows: u32,
274 ) -> StorageResult<Vec<Note>> {
275 self.notes()
276 .map_err(|error| map_open_error(error, StorageCapability::Notes, "notes"))?
277 .query_notes_filtered_bounded(namespace, filter, max_rows)
278 .await
279 }
280
281 async fn count_notes(&self, namespace: &str, kind: Option<&str>) -> StorageResult<u64> {
282 self.notes()
283 .map_err(|error| map_open_error(error, StorageCapability::Notes, "notes"))?
284 .count_notes(namespace, kind)
285 .await
286 }
287
288 async fn count_notes_in_namespaces(
289 &self,
290 namespaces: &[String],
291 kind: Option<&str>,
292 ) -> StorageResult<u64> {
293 self.notes()
294 .map_err(|error| map_open_error(error, StorageCapability::Notes, "notes"))?
295 .count_notes_in_namespaces(namespaces, kind)
296 .await
297 }
298
299 async fn try_insert_note(&self, note: Note) -> StorageResult<bool> {
300 self.notes()
301 .map_err(|error| map_open_error(error, StorageCapability::Notes, "notes"))?
302 .try_insert_note(note)
303 .await
304 }
305
306 async fn try_insert_note_with_attachments(
307 &self,
308 _note: Note,
309 _attachments: Vec<khive_storage::Attachment>,
310 ) -> StorageResult<bool> {
311 self.notes()
312 .map_err(|error| map_open_error(error, StorageCapability::Notes, "notes"))?
313 .try_insert_note_with_attachments(_note, _attachments)
314 .await
315 }
316
317 async fn get_notes_batch(&self, ids: &[Uuid]) -> StorageResult<Vec<Note>> {
318 self.notes()
319 .map_err(|error| map_open_error(error, StorageCapability::Notes, "notes"))?
320 .get_notes_batch(ids)
321 .await
322 }
323
324 async fn get_notes_batch_including_deleted(&self, ids: &[Uuid]) -> StorageResult<Vec<Note>> {
325 self.notes()
326 .map_err(|error| map_open_error(error, StorageCapability::Notes, "notes"))?
327 .get_notes_batch_including_deleted(ids)
328 .await
329 }
330
331 async fn get_note_visibility_batch(&self, ids: &[Uuid]) -> StorageResult<Vec<NoteVisibility>> {
332 self.notes()
333 .map_err(|error| map_open_error(error, StorageCapability::Notes, "notes"))?
334 .get_note_visibility_batch(ids)
335 .await
336 }
337}