database: remove DatabaseHelper from MemoryDatabase

Signed-off-by: Yuki Kishimoto <[email protected]>

Author: yukibtc

CHANGELOG.md

@@ -53,6 +53,7 @@
 * nostr: update `RelayMessage::NegErr` variant ([Yuki Kishimoto])
 * database: add manual trait implementations for `BTreeCappedSet` ([Yuki Kishimoto]) 
 * database: replace LRU with custom memory cache for IDs tracking ([Yuki Kishimoto])
+* database: remove `DatabaseHelper` from `MemoryDatabase` ([Yuki Kishimoto])
 * lmdb: use `async-utility` to spawn blocking tasks ([Yuki Kishimoto])
 * ndb: bump `nostr-ndb` to 0.4 ([Yuki Kishimoto])
 * pool: add `PingTracker` and improve relay ping management ([Yuki Kishimoto])

Cargo.lock

@@ -12,16 +12,14 @@ use nostr::prelude::*;
 use tokio::sync::RwLock;
 
 use crate::{
-    Backend, DatabaseError, DatabaseEventResult, DatabaseEventStatus, DatabaseHelper, Events,
-    NostrDatabase, NostrEventsDatabase, RejectedReason, SaveEventStatus,
+    Backend, DatabaseError, DatabaseEventStatus, Events, NostrDatabase, NostrEventsDatabase,
+    RejectedReason, SaveEventStatus,
 };
 
 /// Database options
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct MemoryDatabaseOptions {
-    /// Store events (default: false)
-    pub events: bool,
-    /// Max events and IDs to store in memory (default: 35_000)
+    /// Max IDs to store in memory (default: 35_000)
     ///
     /// `None` means no limits.
     pub max_events: Option<usize>,
@@ -30,7 +28,6 @@ pub struct MemoryDatabaseOptions {
 impl Default for MemoryDatabaseOptions {
     fn default() -> Self {
         Self {
-            events: false,
             max_events: Some(35_000),
         }
     }
@@ -44,11 +41,11 @@ impl MemoryDatabaseOptions {
 }
 
 /// Memory Database (RAM)
+///
+/// This database keep track only of seen event IDs!
 #[derive(Debug, Clone)]
 pub struct MemoryDatabase {
-    opts: MemoryDatabaseOptions,
     seen_event_ids: Arc<RwLock<SeenTracker>>,
-    helper: DatabaseHelper,
 }
 
 impl Default for MemoryDatabase {
@@ -66,12 +63,7 @@ impl MemoryDatabase {
     /// New Memory database
     pub fn with_opts(opts: MemoryDatabaseOptions) -> Self {
         Self {
-            opts,
             seen_event_ids: Arc::new(RwLock::new(SeenTracker::new(opts.max_events))),
-            helper: match opts.max_events {
-                Some(max) => DatabaseHelper::bounded(max),
-                None => DatabaseHelper::unbounded(),
-            },
         }
     }
 }
@@ -84,9 +76,6 @@ impl NostrDatabase for MemoryDatabase {
     }
 
     async fn wipe(&self) -> Result<(), DatabaseError> {
-        // Clear helper
-        self.helper.clear().await;
-
         // Clear
         let mut seen_event_ids = self.seen_event_ids.write().await;
         seen_event_ids.clear();
@@ -98,46 +87,28 @@ impl NostrDatabase for MemoryDatabase {
 #[cfg_attr(not(target_arch = "wasm32"), async_trait)]
 impl NostrEventsDatabase for MemoryDatabase {
     async fn save_event(&self, event: &Event) -> Result<SaveEventStatus, DatabaseError> {
-        if self.opts.events {
-            let DatabaseEventResult { status, .. } = self.helper.index_event(event).await;
-            Ok(status)
-        } else {
-            // Mark it as seen
-            let mut seen_event_ids = self.seen_event_ids.write().await;
-            seen_event_ids.seen(event.id, None);
+        // Mark it as seen
+        let mut seen_event_ids = self.seen_event_ids.write().await;
+        seen_event_ids.seen(event.id, None);
 
-            Ok(SaveEventStatus::Rejected(RejectedReason::Other))
-        }
+        Ok(SaveEventStatus::Rejected(RejectedReason::Other))
     }
 
     async fn check_id(&self, event_id: &EventId) -> Result<DatabaseEventStatus, DatabaseError> {
-        if self.opts.events {
-            if self.helper.has_event_id_been_deleted(event_id).await {
-                Ok(DatabaseEventStatus::Deleted)
-            } else if self.helper.has_event(event_id).await {
-                Ok(DatabaseEventStatus::Saved)
-            } else {
-                Ok(DatabaseEventStatus::NotExistent)
-            }
+        let seen_event_ids = self.seen_event_ids.read().await;
+        Ok(if seen_event_ids.contains(event_id) {
+            DatabaseEventStatus::Saved
         } else {
-            let seen_event_ids = self.seen_event_ids.read().await;
-            Ok(if seen_event_ids.contains(event_id) {
-                DatabaseEventStatus::Saved
-            } else {
-                DatabaseEventStatus::NotExistent
-            })
-        }
+            DatabaseEventStatus::NotExistent
+        })
     }
 
     async fn has_coordinate_been_deleted(
         &self,
-        coordinate: &Coordinate,
-        timestamp: &Timestamp,
+        _coordinate: &Coordinate,
+        _timestamp: &Timestamp,
     ) -> Result<bool, DatabaseError> {
-        Ok(self
-            .helper
-            .has_coordinate_been_deleted(coordinate, timestamp)
-            .await)
+        Ok(false)
     }
 
     async fn event_id_seen(
@@ -158,27 +129,26 @@ impl NostrEventsDatabase for MemoryDatabase {
         Ok(seen_event_ids.get(event_id).cloned())
     }
 
-    async fn event_by_id(&self, id: &EventId) -> Result<Option<Event>, DatabaseError> {
-        Ok(self.helper.event_by_id(id).await)
+    async fn event_by_id(&self, _id: &EventId) -> Result<Option<Event>, DatabaseError> {
+        Ok(None)
     }
 
-    async fn count(&self, filters: Vec<Filter>) -> Result<usize, DatabaseError> {
-        Ok(self.helper.count(filters).await)
+    async fn count(&self, _filters: Vec<Filter>) -> Result<usize, DatabaseError> {
+        Ok(0)
     }
 
     async fn query(&self, filters: Vec<Filter>) -> Result<Events, DatabaseError> {
-        Ok(self.helper.query(filters).await)
+        Ok(Events::new(&filters))
     }
 
     async fn negentropy_items(
         &self,
-        filter: Filter,
+        _filter: Filter,
     ) -> Result<Vec<(EventId, Timestamp)>, DatabaseError> {
-        Ok(self.helper.negentropy_items(filter).await)
+        Ok(Vec::new())
     }
 
-    async fn delete(&self, filter: Filter) -> Result<(), DatabaseError> {
-        self.helper.delete(filter).await;
+    async fn delete(&self, _filter: Filter) -> Result<(), DatabaseError> {
         Ok(())
     }
 }

crates/nostr-database/src/memory.rs

@@ -39,7 +39,6 @@ impl NostrLMDB {
         Ok(Self {
             db: Store::open(path).map_err(DatabaseError::backend)?,
             temp: MemoryDatabase::with_opts(MemoryDatabaseOptions {
-                events: false,
                 max_events: Some(100_000),
             }),
         })

crates/nostr-lmdb/src/lib.rs

@@ -38,7 +38,6 @@ impl NostrRedb {
         Ok(Self {
             db: Store::persistent(path).map_err(DatabaseError::backend)?,
             temp: MemoryDatabase::with_opts(MemoryDatabaseOptions {
-                events: false,
                 max_events: Some(100_000),
             }),
         })
@@ -50,7 +49,6 @@ impl NostrRedb {
         Ok(Self {
             db: Store::in_memory().map_err(DatabaseError::backend)?,
             temp: MemoryDatabase::with_opts(MemoryDatabaseOptions {
-                events: false,
                 max_events: Some(100_000),
             }),
         })

crates/nostr-redb/src/lib.rs

@@ -22,6 +22,7 @@ atomic-destructor.workspace = true
 negentropy.workspace = true
 nostr = { workspace = true, default-features = false, features = ["std"] }
 nostr-database.workspace = true
+nostr-redb.workspace = true
 thiserror.workspace = true
 tokio = { workspace = true, features = ["macros", "net", "sync"] }
 tracing.workspace = true

crates/nostr-relay-builder/Cargo.toml

@@ -4,14 +4,16 @@
 
 use std::time::Duration;
 
+use nostr_redb::NostrRedb;
 use nostr_relay_builder::prelude::*;
 
 #[tokio::main]
 async fn main() -> Result<()> {
     tracing_subscriber::fmt::init();
 
+    let database = NostrRedb::in_memory()?;
     let tor = RelayBuilderHiddenService::new("rust-nostr-local-hs-test");
-    let builder = RelayBuilder::default().tor(tor);
+    let builder = RelayBuilder::new(database).tor(tor);
 
     let relay = LocalRelay::run(builder).await?;
 

crates/nostr-relay-builder/examples/local-with-hs.rs

@@ -5,6 +5,7 @@ use std::collections::HashSet;
 use std::net::SocketAddr;
 use std::time::Duration;
 
+use nostr_redb::NostrRedb;
 use nostr_relay_builder::prelude::*;
 
 /// Accept only certain event kinds
@@ -54,7 +55,8 @@ async fn main() -> Result<()> {
 
     let low_author_limit = RejectAuthorLimit { limit: 2 };
 
-    let builder = RelayBuilder::default()
+    let database = NostrRedb::in_memory()?;
+    let builder = RelayBuilder::new(database)
         .write_policy(accept_profile_data)
         .query_policy(low_author_limit);
 

crates/nostr-relay-builder/examples/policy.rs

@@ -14,6 +14,7 @@ use std::sync::Arc;
 use std::time::Duration;
 
 use nostr_database::prelude::*;
+use nostr_redb::NostrRedb;
 
 /// Rate limit
 #[derive(Debug, Clone)]
@@ -190,13 +191,22 @@ pub struct RelayBuilder {
 
 impl Default for RelayBuilder {
     fn default() -> Self {
+        // TODO: remove?
+        let database = NostrRedb::in_memory().unwrap();
+        Self::new(database)
+    }
+}
+
+impl RelayBuilder {
+    /// New relay builder
+    pub fn new<T>(database: T) -> Self
+    where
+        T: IntoNostrEventsDatabase,
+    {
         Self {
             addr: None,
             port: None,
-            database: Arc::new(MemoryDatabase::with_opts(MemoryDatabaseOptions {
-                events: true,
-                max_events: Some(75_000),
-            })),
+            database: database.into_database(),
             mode: RelayBuilderMode::default(),
             rate_limit: RateLimit::default(),
             nip42: None,
@@ -209,9 +219,7 @@ impl Default for RelayBuilder {
             test: RelayTestOptions::default(),
         }
     }
-}
 
-impl RelayBuilder {
     /// Set IP address
     #[inline]
     pub fn addr(mut self, ip: IpAddr) -> Self {
@@ -226,16 +234,6 @@ impl RelayBuilder {
         self
     }
 
-    /// Set database
-    #[inline]
-    pub fn database<D>(mut self, database: D) -> Self
-    where
-        D: IntoNostrEventsDatabase,
-    {
-        self.database = database.into_database();
-        self
-    }
-
     /// Set mode
     #[inline]
     pub fn mode(mut self, mode: RelayBuilderMode) -> Self {

crates/nostr-relay-builder/src/builder.rs

@@ -8,6 +8,7 @@ use std::io;
 
 #[cfg(feature = "tor")]
 use async_wsocket::native::tor;
+use nostr_database::DatabaseError;
 use thiserror::Error;
 
 /// Relay builder error
@@ -16,6 +17,9 @@ pub enum Error {
     /// I/O error
     #[error(transparent)]
     IO(#[from] io::Error),
+    /// Database error
+    #[error(transparent)]
+    Database(#[from] DatabaseError),
     /// Tor error
     #[cfg(feature = "tor")]
     #[error(transparent)]

crates/nostr-relay-builder/src/error.rs

@@ -8,6 +8,7 @@ use std::ops::Deref;
 
 use nostr::prelude::*;
 use nostr_database::prelude::*;
+use nostr_redb::NostrRedb;
 
 use crate::builder::{RelayBuilder, RelayTestOptions};
 use crate::error::Error;
@@ -31,7 +32,8 @@ impl MockRelay {
     /// Run mock relay
     #[inline]
     pub async fn run() -> Result<Self, Error> {
-        let builder = RelayBuilder::default();
+        let database = NostrRedb::in_memory()?;
+        let builder = RelayBuilder::new(database);
         Ok(Self {
             local: LocalRelay::run(builder).await?,
         })
@@ -40,7 +42,8 @@ impl MockRelay {
     /// Run unresponsive relay
     #[inline]
     pub async fn run_with_opts(opts: RelayTestOptions) -> Result<Self, Error> {
-        let builder = RelayBuilder::default().test(opts);
+        let database = NostrRedb::in_memory()?;
+        let builder = RelayBuilder::new(database).test(opts);
         Ok(Self {
             local: LocalRelay::run(builder).await?,
         })