Skip to main content

khive_db/backend/core_stores/
note.rs

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}