WIP

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

Author: yukibtc

Cargo.lock

@@ -52,6 +52,7 @@ nostr-gossip-memory = { version = "0.44", path = "./gossip/nostr-gossip-memory",
 nostr-gossip-test-suite = { path = "./gossip/nostr-gossip-test-suite" }
 nostr-lmdb = { version = "0.44", path = "./database/nostr-lmdb", default-features = false }
 nostr-ndb = { version = "0.44", path = "./database/nostr-ndb", default-features = false }
+nostr-sqldb = { version = "0.44", path = "./database/nostr-sqldb", default-features = false }
 nostr-relay-builder = { version = "0.44", path = "./crates/nostr-relay-builder", default-features = false }
 nostr-relay-pool = { version = "0.44", path = "./crates/nostr-relay-pool", default-features = false }
 reqwest = { version = "0.12", default-features = false }

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "nostr-sqldb"
-version = "0.42.0"
+version = "0.44.0"
 edition = "2021"
 description = "SQL storage backend for Nostr apps"
 authors.workspace = true
@@ -31,6 +31,7 @@ sqlx = { version = "0.8", features = ["migrate", "runtime-tokio"] }
 tokio = { workspace = true, features = ["sync"] }
 
 [dev-dependencies]
+nostr-database-test-suite.workspace = true
 nostr-relay-builder.workspace = true
 tempfile.workspace = true
 tokio.workspace = true

database/nostr-sqldb/Cargo.toml

@@ -21,8 +21,9 @@ async fn main() -> Result<()> {
     let builder = RelayBuilder::default().database(db);
 
     // Create local relay
-    let relay = LocalRelay::run(builder).await?;
-    println!("Url: {}", relay.url());
+    let relay = LocalRelay::new(builder);
+    relay.run().await?;
+    println!("Url: {}", relay.url().await);
 
     // Keep up the program
     loop {

database/nostr-sqldb/examples/sqlite-relay.rs

@@ -16,5 +16,7 @@ compile_error!("At least one database backend must be enabled");
 pub mod db;
 pub mod error;
 mod model;
+// #[cfg(feature = "sqlite")]
+// pub mod sqlite;
 
 pub use self::db::{NostrSql, NostrSqlBackend};

database/nostr-sqldb/src/db.rs

@@ -16,6 +16,13 @@ pub(crate) struct EventDb {
     pub deleted: bool,
 }
 
+impl EventDb {
+    #[inline]
+    pub(super) fn is_deleted(&self) -> bool {
+        self.deleted
+    }
+}
+
 #[derive(Debug, Clone, FromRow)]
 pub(crate) struct EventTagDb {
     pub tag: String,
@@ -36,7 +43,7 @@ impl EventDataDb {
             event: EventDb {
                 id: event.id.as_bytes().to_vec(),
                 pubkey: event.pubkey.as_bytes().to_vec(),
-                created_at: event.created_at.as_u64() as i64,
+                created_at: event.created_at.as_secs() as i64,
                 kind: event.kind.as_u16() as i64,
                 payload: event.encode(fbb).to_vec(),
                 deleted: false,

database/nostr-sqldb/src/lib.rs

@@ -0,0 +1,109 @@
+use std::path::Path;
+use std::sync::Arc;
+
+use sqlx::{Sqlite, SqlitePool};
+use sqlx::migrate::Migrator;
+use sqlx::sqlite::SqliteConnectOptions;
+use tokio::sync::Mutex;
+use nostr::{Event, EventId, Filter};
+use nostr::prelude::BoxedFuture;
+use nostr_database::{Backend, DatabaseError, DatabaseEventStatus, Events, FlatBufferBuilder, NostrDatabase, SaveEventStatus};
+
+use crate::db::NostrSql;
+use crate::error::Error;
+
+#[derive(Debug, Clone)]
+pub struct NostrSqlite {
+    db: NostrSql<Sqlite>
+}
+
+impl NostrSqlite {
+    /// Open SQLite database
+    pub async fn open<P>(path: P) -> Result<Self, Error>
+    where
+        P: AsRef<Path>,
+    {
+        // Build SQLite connection options
+        let opts: SqliteConnectOptions =
+            SqliteConnectOptions::new().create_if_missing(true).filename(path);
+
+        // Connect to SQLite database
+        let pool: SqlitePool = SqlitePool::connect_with(opts).await?;
+
+        // Run migrations
+        let migrator: Migrator = sqlx::migrate!("migrations/sqlite");
+        migrator.run(&pool).await?;
+
+        Ok(Self {
+            db: NostrSql::new(pool),
+        })
+    }
+}
+
+impl NostrDatabase for NostrSqlite {
+    fn backend(&self) -> Backend {
+        self.db.backend()
+    }
+
+    fn save_event<'a>(&'a self, event: &'a Event) -> BoxedFuture<'a, Result<SaveEventStatus, DatabaseError>> {
+        self.db.save_event(event)
+    }
+
+    fn check_id<'a>(&'a self, event_id: &'a EventId) -> BoxedFuture<'a, Result<DatabaseEventStatus, DatabaseError>> {
+        self.db.check_id(event_id)
+    }
+
+    fn event_by_id<'a>(&'a self, event_id: &'a EventId) -> BoxedFuture<'a, Result<Option<Event>, DatabaseError>> {
+        self.db.event_by_id(event_id)
+    }
+
+    fn count(&self, filter: Filter) -> BoxedFuture<Result<usize, DatabaseError>> {
+        self.db.count(filter)
+    }
+
+    fn query(&self, filter: Filter) -> BoxedFuture<Result<Events, DatabaseError>> {
+        self.db.query(filter)
+    }
+
+    fn delete(&self, filter: Filter) -> BoxedFuture<Result<(), DatabaseError>> {
+        self.db.delete(filter)
+    }
+
+    fn wipe(&self) -> BoxedFuture<Result<(), DatabaseError>> {
+        self.db.wipe()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use nostr_database_test_suite::database_unit_tests;
+    use tempfile::TempDir;
+
+    use super::*;
+
+    struct TempDatabase {
+        db: NostrSqlite,
+        // Needed to avoid the drop and deletion of temp folder
+        _temp: TempDir,
+    }
+
+    impl Deref for TempDatabase {
+        type Target = NostrSqlite;
+
+        fn deref(&self) -> &Self::Target {
+            &self.db
+        }
+    }
+
+    impl TempDatabase {
+        async fn new() -> Self {
+            let path = tempfile::tempdir().unwrap();
+            Self {
+                db: NostrSqlite::open(path.path().join("temp.db")).await.unwrap(),
+                _temp: path,
+            }
+        }
+    }
+
+    database_unit_tests!(TempDatabase, TempDatabase::new);
+}