Improve the abstraction with fewer generics

As suggested by @thesimplekid

crates/cdk-sql-common/src/mint/auth/mod.rs

@@ -16,29 +16,23 @@ use tracing::instrument;
 use super::{sql_row_to_blind_signature, sql_row_to_keyset_info, SQLTransaction};
 use crate::column_as_string;
 use crate::common::migrate;
-use crate::database::{ConnectionWithTransaction, DatabaseConnector};
+use crate::database::{ConnectionWithTransaction, DatabaseExecutor};
 use crate::mint::Error;
-use crate::pool::{Pool, PooledResource, ResourceManager};
+use crate::pool::{DatabasePool, Pool, PooledResource};
 use crate::stmt::query;
 
 /// Mint SQL Database
 #[derive(Debug, Clone)]
-pub struct SQLMintAuthDatabase<DB, RM, C, E>
+pub struct SQLMintAuthDatabase<RM>
 where
-    DB: DatabaseConnector,
-    RM: ResourceManager<Resource = DB, Config = C, Error = E>,
-    C: Debug + Clone + Send + Sync,
-    E: Debug + std::error::Error + Send + Sync + 'static,
+    RM: DatabasePool + 'static,
 {
     pool: Arc<Pool<RM>>,
 }
 
-impl<DB, RM, C, E> SQLMintAuthDatabase<DB, RM, C, E>
+impl<RM> SQLMintAuthDatabase<RM>
 where
-    DB: DatabaseConnector + 'static,
-    RM: ResourceManager<Resource = DB, Config = C, Error = E> + 'static,
-    C: Debug + Clone + Send + Sync,
-    E: Debug + std::error::Error + Send + Sync + 'static,
+    RM: DatabasePool + 'static,
 {
     /// Creates a new instance
     pub async fn new<X>(db: X) -> Result<Self, Error>
@@ -53,7 +47,7 @@ where
     /// Migrate
     async fn migrate(conn: PooledResource<RM>) -> Result<(), Error> {
         let tx = ConnectionWithTransaction::new(conn).await?;
-        migrate(&tx, DB::name(), MIGRATIONS).await?;
+        migrate(&tx, RM::Connection::name(), MIGRATIONS).await?;
         tx.commit().await?;
         Ok(())
     }
@@ -64,12 +58,9 @@ mod migrations;
 
 
 #[async_trait]
-impl<DB, RM, C, E> MintAuthTransaction<database::Error> for SQLTransaction<DB, RM, C, E>
+impl<RM> MintAuthTransaction<database::Error> for SQLTransaction<RM>
 where
-    DB: DatabaseConnector,
-    RM: ResourceManager<Resource = DB, Config = C, Error = E>,
-    C: Debug + Clone + Send + Sync,
-    E: Debug + std::error::Error + Send + Sync + 'static,
+    RM: DatabasePool + 'static,
 {
     #[instrument(skip(self))]
     async fn set_active_keyset(&mut self, id: Id) -> Result<(), database::Error> {
@@ -244,12 +235,9 @@ where
 }
 
 #[async_trait]
-impl<DB, RM, C, E> MintAuthDatabase for SQLMintAuthDatabase<DB, RM, C, E>
+impl<RM> MintAuthDatabase for SQLMintAuthDatabase<RM>
 where
-    DB: DatabaseConnector + 'static,
-    RM: ResourceManager<Resource = DB, Config = C, Error = E> + 'static,
-    C: Debug + Clone + Send + Sync,
-    E: Debug + std::error::Error + Send + Sync + 'static,
+    RM: DatabasePool + 'static,
 {
     type Err = database::Error;
 

crates/cdk-sql-common/src/mint/mod.rs

@@ -39,8 +39,8 @@ use tracing::instrument;
 use uuid::Uuid;
 
 use crate::common::migrate;
-use crate::database::{ConnectionWithTransaction, DatabaseConnector, DatabaseExecutor};
-use crate::pool::{Pool, PooledResource, ResourceManager};
+use crate::database::{ConnectionWithTransaction, DatabaseExecutor};
+use crate::pool::{DatabasePool, Pool, PooledResource};
 use crate::stmt::{query, Column};
 use crate::{
     column_as_nullable_number, column_as_nullable_string, column_as_number, column_as_string,
@@ -59,25 +59,19 @@ pub use auth::SQLMintAuthDatabase;
 
 /// Mint SQL Database
 #[derive(Debug, Clone)]
-pub struct SQLMintDatabase<DB, RM, C, E>
+pub struct SQLMintDatabase<RM>
 where
-    DB: DatabaseConnector,
-    RM: ResourceManager<Resource = DB, Config = C, Error = E>,
-    C: Debug + Clone + Send + Sync,
-    E: Debug + std::error::Error + Send + Sync + 'static,
+    RM: DatabasePool + 'static,
 {
     pool: Arc<Pool<RM>>,
 }
 
 /// SQL Transaction Writer
-pub struct SQLTransaction<DB, RM, C, E>
+pub struct SQLTransaction<RM>
 where
-    DB: DatabaseConnector + 'static,
-    RM: ResourceManager<Resource = DB, Config = C, Error = E> + 'static,
-    C: Debug + Clone + Send + Sync,
-    E: Debug + std::error::Error + Send + Sync + 'static,
+    RM: DatabasePool + 'static,
 {
-    inner: ConnectionWithTransaction<DB, PooledResource<RM>>,
+    inner: ConnectionWithTransaction<RM::Connection, PooledResource<RM>>,
 }
 
 #[inline(always)]
@@ -122,12 +116,9 @@ where
     Ok(())
 }
 
-impl<DB, RM, C, E> SQLMintDatabase<DB, RM, C, E>
+impl<RM> SQLMintDatabase<RM>
 where
-    DB: DatabaseConnector + 'static,
-    RM: ResourceManager<Resource = DB, Config = C, Error = E> + 'static,
-    C: Debug + Clone + Send + Sync,
-    E: Debug + std::error::Error + Send + Sync + 'static,
+    RM: DatabasePool + 'static,
 {
     /// Creates a new instance
     pub async fn new<X>(db: X) -> Result<Self, Error>
@@ -144,7 +135,7 @@ where
     /// Migrate
     async fn migrate(conn: PooledResource<RM>) -> Result<(), Error> {
         let tx = ConnectionWithTransaction::new(conn).await?;
-        migrate(&tx, DB::name(), MIGRATIONS).await?;
+        migrate(&tx, RM::Connection::name(), MIGRATIONS).await?;
         tx.commit().await?;
         Ok(())
     }
@@ -166,12 +157,9 @@ where
 }
 
 #[async_trait]
-impl<DB, RM, C, E> database::MintProofsTransaction<'_> for SQLTransaction<DB, RM, C, E>
+impl<RM> database::MintProofsTransaction<'_> for SQLTransaction<RM>
 where
-    DB: DatabaseConnector,
-    RM: ResourceManager<Resource = DB, Config = C, Error = E>,
-    C: Debug + Clone + Send + Sync,
-    E: Debug + std::error::Error + Send + Sync + 'static,
+    RM: DatabasePool + 'static,
 {
     type Err = Error;
 
@@ -283,12 +271,9 @@ where
 }
 
 #[async_trait]
-impl<DB, RM, C, E> database::MintTransaction<'_, Error> for SQLTransaction<DB, RM, C, E>
+impl<RM> database::MintTransaction<'_, Error> for SQLTransaction<RM>
 where
-    DB: DatabaseConnector,
-    RM: ResourceManager<Resource = DB, Config = C, Error = E>,
-    C: Debug + Clone + Send + Sync,
-    E: Debug + std::error::Error + Send + Sync + 'static,
+    RM: DatabasePool + 'static,
 {
     async fn set_mint_info(&mut self, mint_info: MintInfo) -> Result<(), Error> {
         Ok(set_to_config(&self.inner, "mint_info", &mint_info).await?)
@@ -300,12 +285,9 @@ where
 }
 
 #[async_trait]
-impl<DB, RM, C, E> MintDbWriterFinalizer for SQLTransaction<DB, RM, C, E>
+impl<RM> MintDbWriterFinalizer for SQLTransaction<RM>
 where
-    DB: DatabaseConnector,
-    RM: ResourceManager<Resource = DB, Config = C, Error = E>,
-    C: Debug + Clone + Send + Sync,
-    E: Debug + std::error::Error + Send + Sync + 'static,
+    RM: DatabasePool + 'static,
 {
     type Err = Error;
 
@@ -379,12 +361,9 @@ WHERE quote_id=:quote_id
 }
 
 #[async_trait]
-impl<DB, RM, C, E> MintKeyDatabaseTransaction<'_, Error> for SQLTransaction<DB, RM, C, E>
+impl<RM> MintKeyDatabaseTransaction<'_, Error> for SQLTransaction<RM>
 where
-    DB: DatabaseConnector,
-    RM: ResourceManager<Resource = DB, Config = C, Error = E>,
-    C: Debug + Clone + Send + Sync,
-    E: Debug + std::error::Error + Send + Sync + 'static,
+    RM: DatabasePool + 'static,
 {
     async fn add_keyset_info(&mut self, keyset: MintKeySetInfo) -> Result<(), Error> {
         query(
@@ -441,12 +420,9 @@ where
 }
 
 #[async_trait]
-impl<DB, RM, C, E> MintKeysDatabase for SQLMintDatabase<DB, RM, C, E>
+impl<RM> MintKeysDatabase for SQLMintDatabase<RM>
 where
-    DB: DatabaseConnector + 'static,
-    RM: ResourceManager<Resource = DB, Config = C, Error = E> + 'static,
-    C: Debug + Clone + Send + Sync,
-    E: Debug + std::error::Error + Send + Sync + 'static,
+    RM: DatabasePool + 'static,
 {
     type Err = Error;
 
@@ -542,12 +518,9 @@ where
 }
 
 #[async_trait]
-impl<DB, RM, C, E> MintQuotesTransaction<'_> for SQLTransaction<DB, RM, C, E>
+impl<RM> MintQuotesTransaction<'_> for SQLTransaction<RM>
 where
-    DB: DatabaseConnector,
-    RM: ResourceManager<Resource = DB, Config = C, Error = E>,
-    C: Debug + Clone + Send + Sync,
-    E: Debug + std::error::Error + Send + Sync + 'static,
+    RM: DatabasePool + 'static,
 {
     type Err = Error;
 
@@ -1065,12 +1038,9 @@ VALUES (:quote_id, :amount, :timestamp);
 }
 
 #[async_trait]
-impl<DB, RM, C, E> MintQuotesDatabase for SQLMintDatabase<DB, RM, C, E>
+impl<RM> MintQuotesDatabase for SQLMintDatabase<RM>
 where
-    DB: DatabaseConnector,
-    RM: ResourceManager<Resource = DB, Config = C, Error = E>,
-    C: Debug + Clone + Send + Sync,
-    E: Debug + std::error::Error + Send + Sync + 'static,
+    RM: DatabasePool + 'static,
 {
     type Err = Error;
 
@@ -1291,12 +1261,9 @@ where
 }
 
 #[async_trait]
-impl<DB, RM, C, E> MintProofsDatabase for SQLMintDatabase<DB, RM, C, E>
+impl<RM> MintProofsDatabase for SQLMintDatabase<RM>
 where
-    DB: DatabaseConnector,
-    RM: ResourceManager<Resource = DB, Config = C, Error = E>,
-    C: Debug + Clone + Send + Sync,
-    E: Debug + std::error::Error + Send + Sync + 'static,
+    RM: DatabasePool + 'static,
 {
     type Err = Error;
 
@@ -1400,12 +1367,9 @@ where
 }
 
 #[async_trait]
-impl<DB, RM, C, E> MintSignatureTransaction<'_> for SQLTransaction<DB, RM, C, E>
+impl<RM> MintSignatureTransaction<'_> for SQLTransaction<RM>
 where
-    DB: DatabaseConnector,
-    RM: ResourceManager<Resource = DB, Config = C, Error = E>,
-    C: Debug + Clone + Send + Sync,
-    E: Debug + std::error::Error + Send + Sync + 'static,
+    RM: DatabasePool + 'static,
 {
     type Err = Error;
 
@@ -1493,12 +1457,9 @@ where
 }
 
 #[async_trait]
-impl<DB, RM, C, E> MintSignaturesDatabase for SQLMintDatabase<DB, RM, C, E>
+impl<RM> MintSignaturesDatabase for SQLMintDatabase<RM>
 where
-    DB: DatabaseConnector,
-    RM: ResourceManager<Resource = DB, Config = C, Error = E>,
-    C: Debug + Clone + Send + Sync,
-    E: Debug + std::error::Error + Send + Sync + 'static,
+    RM: DatabasePool + 'static,
 {
     type Err = Error;
 
@@ -1604,12 +1565,9 @@ where
 }
 
 #[async_trait]
-impl<DB, RM, C, E> MintDatabase<Error> for SQLMintDatabase<DB, RM, C, E>
+impl<RM> MintDatabase<Error> for SQLMintDatabase<RM>
 where
-    DB: DatabaseConnector + 'static,
-    RM: ResourceManager<Resource = DB, Config = C, Error = E> + 'static,
-    C: Debug + Clone + Send + Sync,
-    E: Debug + std::error::Error + Send + Sync + 'static,
+    RM: DatabasePool + 'static,
 {
     async fn begin_transaction<'a>(
         &'a self,

crates/cdk-sql-common/src/pool.rs

@@ -8,8 +8,10 @@ use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
 use std::sync::{Arc, Condvar, Mutex};
 use std::time::Duration;
 
+use crate::database::DatabaseConnector;
+
 /// Pool error
-#[derive(thiserror::Error, Debug)]
+#[derive(Debug, thiserror::Error)]
 pub enum Error<E>
 where
     E: std::error::Error + Send + Sync + 'static,
@@ -28,7 +30,7 @@ where
 }
 
 /// Configuration
-pub trait Config: Clone + Debug + Send + Sync {
+pub trait DatabaseConfig: Clone + Debug + Send + Sync {
     /// Max resource sizes
     fn max_size(&self) -> usize;
 
@@ -37,12 +39,12 @@ pub trait Config: Clone + Debug + Send + Sync {
 }
 
 /// Trait to manage resources
-pub trait ResourceManager: Debug {
+pub trait DatabasePool: Debug {
     /// The resource to be pooled
-    type Resource: Debug;
+    type Connection: DatabaseConnector;
 
     /// The configuration that is needed in order to create the resource
-    type Config: Config;
+    type Config: DatabaseConfig;
 
     /// The error the resource may return when creating a new instance
     type Error: Debug + std::error::Error + Send + Sync + 'static;
@@ -55,20 +57,20 @@ pub trait ResourceManager: Debug {
         config: &Self::Config,
         stale: Arc<AtomicBool>,
         timeout: Duration,
-    ) -> Result<Self::Resource, Error<Self::Error>>;
+    ) -> Result<Self::Connection, Error<Self::Error>>;
 
     /// The object is dropped
-    fn drop(_resource: Self::Resource) {}
+    fn drop(_resource: Self::Connection) {}
 }
 
 /// Generic connection pool of resources R
 #[derive(Debug)]
 pub struct Pool<RM>
 where
-    RM: ResourceManager,
+    RM: DatabasePool,
 {
     config: RM::Config,
-    queue: Mutex<Vec<(Arc<AtomicBool>, RM::Resource)>>,
+    queue: Mutex<Vec<(Arc<AtomicBool>, RM::Connection)>>,
     in_use: AtomicUsize,
     max_size: usize,
     default_timeout: Duration,
@@ -78,15 +80,15 @@ where
 /// The pooled resource
 pub struct PooledResource<RM>
 where
-    RM: ResourceManager,
+    RM: DatabasePool,
 {
-    resource: Option<(Arc<AtomicBool>, RM::Resource)>,
+    resource: Option<(Arc<AtomicBool>, RM::Connection)>,
     pool: Arc<Pool<RM>>,
 }
 
 impl<RM> Debug for PooledResource<RM>
 where
-    RM: ResourceManager,
+    RM: DatabasePool,
 {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(f, "Resource: {:?}", self.resource)
@@ -95,7 +97,7 @@ where
 
 impl<RM> Drop for PooledResource<RM>
 where
-    RM: ResourceManager,
+    RM: DatabasePool,
 {
     fn drop(&mut self) {
         if let Some(resource) = self.resource.take() {
@@ -111,9 +113,9 @@ where
 
 impl<RM> Deref for PooledResource<RM>
 where
-    RM: ResourceManager,
+    RM: DatabasePool,
 {
-    type Target = RM::Resource;
+    type Target = RM::Connection;
 
     fn deref(&self) -> &Self::Target {
         &self.resource.as_ref().expect("resource already dropped").1
@@ -122,7 +124,7 @@ where
 
 impl<RM> DerefMut for PooledResource<RM>
 where
-    RM: ResourceManager,
+    RM: DatabasePool,
 {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.resource.as_mut().expect("resource already dropped").1
@@ -131,7 +133,7 @@ where
 
 impl<RM> Pool<RM>
 where
-    RM: ResourceManager,
+    RM: DatabasePool,
 {
     /// Creates a new pool
     pub fn new(config: RM::Config) -> Arc<Self> {
@@ -206,7 +208,7 @@ where
 
 impl<RM> Drop for Pool<RM>
 where
-    RM: ResourceManager,
+    RM: DatabasePool,
 {
     fn drop(&mut self) {
         if let Ok(mut resources) = self.queue.lock() {

crates/cdk-sql-common/src/wallet/mod.rs

@@ -19,8 +19,8 @@ use cdk_common::{
 use tracing::instrument;
 
 use crate::common::migrate;
-use crate::database::{ConnectionWithTransaction, DatabaseConnector, DatabaseExecutor};
-use crate::pool::{Pool, PooledResource, ResourceManager};
+use crate::database::{ConnectionWithTransaction, DatabaseExecutor};
+use crate::pool::{DatabasePool, Pool, PooledResource};
 use crate::stmt::{query, Column};
 use crate::{
     column_as_binary, column_as_nullable_binary, column_as_nullable_number,
@@ -32,22 +32,16 @@ mod migrations;
 
 /// Wallet SQLite Database
 #[derive(Debug, Clone)]
-pub struct SQLWalletDatabase<DB, RM, C, E>
+pub struct SQLWalletDatabase<RM>
 where
-    DB: DatabaseConnector,
-    RM: ResourceManager<Resource = DB, Config = C, Error = E>,
-    C: Debug + Clone + Send + Sync,
-    E: Debug + std::error::Error + Send + Sync + 'static,
+    RM: DatabasePool + 'static,
 {
     pool: Arc<Pool<RM>>,
 }
 
-impl<DB, RM, C, E> SQLWalletDatabase<DB, RM, C, E>
+impl<RM> SQLWalletDatabase<RM>
 where
-    DB: DatabaseConnector + 'static,
-    RM: ResourceManager<Resource = DB, Config = C, Error = E> + 'static,
-    C: Debug + Clone + Send + Sync,
-    E: Debug + std::error::Error + Send + Sync + 'static,
+    RM: DatabasePool + 'static,
 {
     /// Creates a new instance
     pub async fn new<X>(db: X) -> Result<Self, Error>
@@ -63,7 +57,7 @@ where
     /// Migrate [`WalletSqliteDatabase`]
     async fn migrate(conn: PooledResource<RM>) -> Result<(), Error> {
         let tx = ConnectionWithTransaction::new(conn).await?;
-        migrate(&tx, DB::name(), migrations::MIGRATIONS).await?;
+        migrate(&tx, RM::Connection::name(), migrations::MIGRATIONS).await?;
         // Update any existing keys with missing keyset_u32 values
         Self::add_keyset_u32(&tx).await?;
         tx.commit().await?;
@@ -142,12 +136,9 @@ where
 }
 
 #[async_trait]
-impl<DB, RM, C, E> WalletDatabase for SQLWalletDatabase<DB, RM, C, E>
+impl<RM> WalletDatabase for SQLWalletDatabase<RM>
 where
-    DB: DatabaseConnector + 'static,
-    RM: ResourceManager<Resource = DB, Config = C, Error = E> + 'static,
-    C: Debug + Clone + Send + Sync,
-    E: Debug + std::error::Error + Send + Sync + 'static,
+    RM: DatabasePool + 'static,
 {
     type Err = database::Error;
 

crates/cdk-sqlite/src/common.rs

@@ -3,7 +3,7 @@ use std::sync::atomic::AtomicBool;
 use std::sync::Arc;
 use std::time::Duration;
 
-use cdk_sql_common::pool::{self, ResourceManager};
+use cdk_sql_common::pool::{self, DatabasePool};
 use cdk_sql_common::value::Value;
 use rusqlite::Connection;
 
@@ -16,7 +16,7 @@ pub struct Config {
     password: Option<String>,
 }
 
-impl pool::Config for Config {
+impl pool::DatabaseConfig for Config {
     fn default_timeout(&self) -> Duration {
         Duration::from_secs(5)
     }
@@ -34,10 +34,10 @@ impl pool::Config for Config {
 #[derive(Debug)]
 pub struct SqliteConnectionManager;
 
-impl ResourceManager for SqliteConnectionManager {
+impl DatabasePool for SqliteConnectionManager {
     type Config = Config;
 
-    type Resource = async_sqlite::AsyncSqlite;
+    type Connection = async_sqlite::AsyncSqlite;
 
     type Error = rusqlite::Error;
 
@@ -45,7 +45,7 @@ impl ResourceManager for SqliteConnectionManager {
         config: &Self::Config,
         _stale: Arc<AtomicBool>,
         _timeout: Duration,
-    ) -> Result<Self::Resource, pool::Error<Self::Error>> {
+    ) -> Result<Self::Connection, pool::Error<Self::Error>> {
         let conn = if let Some(path) = config.path.as_ref() {
             Connection::open(path)?
         } else {

crates/cdk-sqlite/src/mint/mod.rs

@@ -3,23 +3,16 @@
 use cdk_sql_common::mint::SQLMintAuthDatabase;
 use cdk_sql_common::SQLMintDatabase;
 
-use crate::async_sqlite;
-use crate::common::{Config, SqliteConnectionManager};
+use crate::common::SqliteConnectionManager;
 
 pub mod memory;
 
 /// Mint SQLite implementation with rusqlite
-pub type MintSqliteDatabase =
-    SQLMintDatabase<async_sqlite::AsyncSqlite, SqliteConnectionManager, Config, rusqlite::Error>;
+pub type MintSqliteDatabase = SQLMintDatabase<SqliteConnectionManager>;
 
 /// Mint Auth database with rusqlite
 #[cfg(feature = "auth")]
-pub type MintSqliteAuthDatabase = SQLMintAuthDatabase<
-    async_sqlite::AsyncSqlite,
-    SqliteConnectionManager,
-    Config,
-    rusqlite::Error,
->;
+pub type MintSqliteAuthDatabase = SQLMintAuthDatabase<SqliteConnectionManager>;
 
 #[cfg(test)]
 mod test {
@@ -30,6 +23,7 @@ mod test {
     use cdk_sql_common::stmt::query;
 
     use super::*;
+    use crate::common::Config;
 
     async fn provide_db() -> MintSqliteDatabase {
         memory::empty().await.unwrap()

crates/cdk-sqlite/src/wallet/mod.rs

@@ -2,14 +2,12 @@
 
 use cdk_sql_common::SQLWalletDatabase;
 
-use crate::async_sqlite;
-use crate::common::{Config, SqliteConnectionManager};
+use crate::common::SqliteConnectionManager;
 
 pub mod memory;
 
 /// Mint SQLite implementation with rusqlite
-pub type WalletSqliteDatabase =
-    SQLWalletDatabase<async_sqlite::AsyncSqlite, SqliteConnectionManager, Config, rusqlite::Error>;
+pub type WalletSqliteDatabase = SQLWalletDatabase<SqliteConnectionManager>;
 
 #[cfg(test)]
 mod tests {