1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
|
use anyhow::Result;
use nostr_sdk::Event;
use std::collections::HashMap;
use std::sync::Arc;
use tokio::sync::RwLock;
use crate::config::Config;
/// Simple in-memory storage for events
/// TODO: Persist to disk for production use
#[derive(Clone)]
pub struct Storage {
events: Arc<RwLock<HashMap<String, Event>>>,
data_path: String,
}
impl Storage {
pub fn new(config: &Config) -> Result<Self> {
// Create data directory if it doesn't exist
std::fs::create_dir_all(&config.relay_data_path)?;
Ok(Storage {
events: Arc::new(RwLock::new(HashMap::new())),
data_path: config.relay_data_path.clone(),
})
}
pub async fn store_event(&self, event: Event) -> Result<()> {
let mut events = self.events.write().await;
events.insert(event.id.to_hex(), event);
Ok(())
}
pub async fn get_event(&self, event_id: &str) -> Option<Event> {
let events = self.events.read().await;
events.get(event_id).cloned()
}
pub async fn query_events<F>(&self, filter: F) -> Vec<Event>
where
F: Fn(&Event) -> bool,
{
let events = self.events.read().await;
events.values().filter(|e| filter(e)).cloned().collect()
}
pub async fn count_events(&self) -> usize {
let events = self.events.read().await;
events.len()
}
}
#[cfg(test)]
mod tests {
use super::*;
use nostr_sdk::{EventBuilder, Keys, Kind};
#[tokio::test]
async fn test_store_and_retrieve() {
let config = Config {
domain: "test".to_string(),
owner_npub: "npub1test".to_string(),
relay_name: "test".to_string(),
relay_description: "test".to_string(),
git_data_path: "./test_data/git".to_string(),
relay_data_path: "./test_data/relay".to_string(),
bind_address: "127.0.0.1:8080".to_string(),
};
let storage = Storage::new(&config).unwrap();
// Create a test event
let keys = Keys::generate();
let event = EventBuilder::text_note("test content")
.sign_with_keys(&keys)
.unwrap();
// Store it
storage.store_event(event.clone()).await.unwrap();
// Retrieve it
let retrieved = storage.get_event(&event.id.to_hex()).await;
assert!(retrieved.is_some());
assert_eq!(retrieved.unwrap().id, event.id);
// Count events
assert_eq!(storage.count_events().await, 1);
}
#[tokio::test]
async fn test_query_events() {
let config = Config {
domain: "test".to_string(),
owner_npub: "npub1test".to_string(),
relay_name: "test".to_string(),
relay_description: "test".to_string(),
git_data_path: "./test_data/git".to_string(),
relay_data_path: "./test_data/relay".to_string(),
bind_address: "127.0.0.1:8080".to_string(),
};
let storage = Storage::new(&config).unwrap();
// Create multiple events
let keys = Keys::generate();
let event1 = EventBuilder::text_note("message 1")
.sign_with_keys(&keys)
.unwrap();
let event2 = EventBuilder::text_note("message 2")
.sign_with_keys(&keys)
.unwrap();
storage.store_event(event1.clone()).await.unwrap();
storage.store_event(event2.clone()).await.unwrap();
// Query all events
let all_events = storage.query_events(|_| true).await;
assert_eq!(all_events.len(), 2);
// Query by kind
let text_notes = storage
.query_events(|e| e.kind == Kind::TextNote)
.await;
assert_eq!(text_notes.len(), 2);
}
}
|