Skip to main content

memrec_common/protocol/
error.rs

1use thiserror::Error;
2use serde::{Deserialize, Serialize};
3
4#[derive(Debug, Error)]
5pub enum MemRecError {
6    #[error("Memory not found: {0}")]
7    MemoryNotFound(uuid::Uuid),
8    
9    #[error("Project not found: {0}")]
10    ProjectNotFound(String),
11    
12    #[error("Storage error: {0}")]
13    StorageError(String),
14    
15    #[error("Invalid request: {0}")]
16    InvalidRequest(String),
17    
18    #[error("Connection error: {0}")]
19    ConnectionError(String),
20    
21    #[error("Embedding error: {0}")]
22    EmbeddingError(String),
23    
24    #[error("Memory already deleted: {0}")]
25    AlreadyDeleted(uuid::Uuid),
26    
27    #[error("Recovery period expired")]
28    RecoveryExpired,
29}
30
31impl From<MemRecError> for JsonRpcError {
32    fn from(err: MemRecError) -> Self {
33        JsonRpcError {
34            code: match err {
35                MemRecError::MemoryNotFound(_) => -32001,
36                MemRecError::ProjectNotFound(_) => -32002,
37                MemRecError::StorageError(_) => -32003,
38                MemRecError::InvalidRequest(_) => -32600,
39                MemRecError::ConnectionError(_) => -32004,
40                MemRecError::EmbeddingError(_) => -32005,
41                MemRecError::AlreadyDeleted(_) => -32006,
42                MemRecError::RecoveryExpired => -32007,
43            },
44            message: err.to_string(),
45            data: None,
46        }
47    }
48}
49
50#[derive(Debug, Clone, Serialize, Deserialize)]
51pub struct JsonRpcError {
52    pub code: i64,
53    pub message: String,
54    #[serde(skip_serializing_if = "Option::is_none")]
55    pub data: Option<String>,
56}
57
58#[cfg(test)]
59mod tests {
60    use super::*;
61    
62    #[test]
63    fn test_error_to_jsonrpc() {
64        let err = MemRecError::MemoryNotFound(uuid::Uuid::nil());
65        let rpc_err: JsonRpcError = err.into();
66        
67        assert_eq!(rpc_err.code, -32001);
68        assert!(rpc_err.message.contains("not found"));
69    }
70    
71    #[test]
72    fn test_jsonrpc_error_serde() {
73        let err = JsonRpcError {
74            code: -32600,
75            message: "Invalid Request".to_string(),
76            data: Some("details".to_string()),
77        };
78        
79        let json = serde_json::to_string(&err).unwrap();
80        let parsed: JsonRpcError = serde_json::from_str(&json).unwrap();
81        
82        assert_eq!(err.code, parsed.code);
83        assert_eq!(err.data, parsed.data);
84    }
85}