Skip to main content

mnemara_core/
store.rs

1use crate::error::Result;
2use crate::model::{MemoryHistoricalState, MemoryQualityState, MemoryRecord};
3use crate::query::{
4    CompactionReport, CompactionRequest, ExportRequest, ImportReport, ImportRequest,
5    IntegrityCheckReport, IntegrityCheckRequest, RecallQuery, RecallResult, RepairReport,
6    RepairRequest, SnapshotManifest, StoreStatsReport, StoreStatsRequest,
7};
8use async_trait::async_trait;
9use serde::{Deserialize, Serialize};
10
11#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
12pub struct UpsertRequest {
13    pub record: MemoryRecord,
14    pub idempotency_key: Option<String>,
15}
16
17#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
18pub struct BatchUpsertRequest {
19    pub requests: Vec<UpsertRequest>,
20}
21
22#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
23pub struct UpsertReceipt {
24    pub record_id: String,
25    pub deduplicated: bool,
26    pub summary_refreshed: bool,
27}
28
29#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
30pub struct DeleteRequest {
31    pub tenant_id: String,
32    pub namespace: String,
33    pub record_id: String,
34    pub hard_delete: bool,
35    pub audit_reason: String,
36}
37
38#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
39pub struct DeleteReceipt {
40    pub record_id: String,
41    pub tombstoned: bool,
42    pub hard_deleted: bool,
43}
44
45#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
46pub struct ArchiveRequest {
47    pub tenant_id: String,
48    pub namespace: String,
49    pub record_id: String,
50    pub dry_run: bool,
51    pub audit_reason: String,
52}
53
54#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
55pub struct ArchiveReceipt {
56    pub record_id: String,
57    pub previous_quality_state: MemoryQualityState,
58    pub previous_historical_state: MemoryHistoricalState,
59    pub quality_state: MemoryQualityState,
60    pub historical_state: MemoryHistoricalState,
61    pub changed: bool,
62    pub dry_run: bool,
63}
64
65#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
66pub struct SuppressRequest {
67    pub tenant_id: String,
68    pub namespace: String,
69    pub record_id: String,
70    pub dry_run: bool,
71    pub audit_reason: String,
72}
73
74#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
75pub struct SuppressReceipt {
76    pub record_id: String,
77    pub previous_quality_state: MemoryQualityState,
78    pub previous_historical_state: MemoryHistoricalState,
79    pub quality_state: MemoryQualityState,
80    pub historical_state: MemoryHistoricalState,
81    pub changed: bool,
82    pub dry_run: bool,
83}
84
85#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
86pub struct RecoverRequest {
87    pub tenant_id: String,
88    pub namespace: String,
89    pub record_id: String,
90    pub dry_run: bool,
91    pub audit_reason: String,
92    pub quality_state: MemoryQualityState,
93    pub historical_state: Option<MemoryHistoricalState>,
94}
95
96#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
97pub struct RecoverReceipt {
98    pub record_id: String,
99    pub previous_quality_state: MemoryQualityState,
100    pub previous_historical_state: MemoryHistoricalState,
101    pub quality_state: MemoryQualityState,
102    pub historical_state: MemoryHistoricalState,
103    pub changed: bool,
104    pub dry_run: bool,
105}
106
107#[async_trait]
108pub trait MemoryStore: Send + Sync {
109    fn backend_kind(&self) -> &'static str {
110        "unknown"
111    }
112
113    async fn upsert(&self, request: UpsertRequest) -> Result<UpsertReceipt>;
114
115    async fn batch_upsert(&self, request: BatchUpsertRequest) -> Result<Vec<UpsertReceipt>>;
116
117    async fn recall(&self, query: RecallQuery) -> Result<RecallResult>;
118
119    async fn compact(&self, request: CompactionRequest) -> Result<CompactionReport>;
120
121    async fn delete(&self, request: DeleteRequest) -> Result<DeleteReceipt>;
122
123    async fn archive(&self, request: ArchiveRequest) -> Result<ArchiveReceipt>;
124
125    async fn suppress(&self, request: SuppressRequest) -> Result<SuppressReceipt>;
126
127    async fn recover(&self, request: RecoverRequest) -> Result<RecoverReceipt>;
128
129    async fn snapshot(&self) -> Result<SnapshotManifest>;
130
131    async fn stats(&self, request: StoreStatsRequest) -> Result<StoreStatsReport>;
132
133    async fn integrity_check(&self, request: IntegrityCheckRequest)
134    -> Result<IntegrityCheckReport>;
135
136    async fn repair(&self, request: RepairRequest) -> Result<RepairReport>;
137
138    async fn export(&self, request: ExportRequest) -> Result<crate::query::PortableStorePackage>;
139
140    async fn import(&self, request: ImportRequest) -> Result<ImportReport>;
141}