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