Make nostr mls sqlite async

[delcin-raj]

Currently, nostr-mls-sqlite-storage uses rusqlite.
But rusqlite is not compatible with async runtimes.
This might cause performance and ergonomic issues in the application development.

In whitenoise-flutter crate it's impossible to pass around Account object references across futures.
In many instances blocking operations are forced right now.

Use sqlx instead, this will improve the performance and ergonomics of the downstream apps.

[delcin-raj]

@erskingardner @yukibtc please share your thoughts on this.

[yukibtc]

Yes, I agree. All the I/O stuff is async in rust-nostr, so also the nostr-mls should be converted to be fully compatible. I'm planning to use sqlx also for this PR #855 (which currently uses diesel), so I agree about using it.

[delcin-raj]

This has to wait, blocked by this openmls/openmls#1812

[delcin-raj]

@erskingardner If they refuse we can fork our own tokio-openmls in the future. I have experience in converting sync implementations to tokio

[erskingardner]

I also ran into this early and had considered trying to build an async version of the storage adapter but put it on hold as something we could get to later.

I'll ping the openMLS folks and see what they think.

[yukibtc]

A temporary solution could be this, which should be easy to implement:

pub struct NostrMlsSqliteStorage {
    /// The OpenMLS storage implementation
    openmls_storage: MlsStorage,
    /// The SQLite connection
    db_connection: Arc<Mutex<Connection>>,
}

impl NostrMlsSqliteStorage {
    // ...

    async fn interact<F, R>(&self, f: F) -> Result<R, Error>
    where
        F: FnOnce(&mut Connection) -> R + Send + 'static,
        R: Send + 'static,
    {
        let arc: Arc<Mutex<Connection>> = self.db_connection.clone();
        let mut conn = arc.lock_owned().await;
        Ok(tokio::task::spawn_blocking(move || f(&mut conn)).await?)
    }
}

And the methods should be updated like this:

impl GroupStorage for NostrMlsSqliteStorage {
    fn all_groups(&self) -> Result<Vec<Group>, GroupError> {
        self.interact(|conn| {
            let mut stmt = conn
                .prepare("SELECT * FROM groups")
                .map_err(into_group_err)?;

            let groups_iter = stmt
                .query_map([], db::row_to_group)
                .map_err(into_group_err)?;

            let mut groups: Vec<Group> = Vec::new();

            for group_result in groups_iter {
                // TODO: simply skip parsing errors? Or log them? Instead of block the whole request
                let group: Group = group_result.map_err(into_group_err)?;
                groups.push(group);
            }

            Ok(groups)
        }).await?
    }
}

So, would require just to add the tokio dep and wrap the current method implementations inside the interact method.

The same for the methods that comes from the openmls crate.