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