chore: renamed DatabaseConnection to DatabaseConnector

Author: TheRustifyer

canyon_core/src/canyon.rs

@@ -2,13 +2,13 @@ use crate::connection::conn_errors::DatasourceNotFound;
 use crate::connection::database_type::DatabaseType;
 use crate::connection::datasources::{CanyonSqlConfig, DatasourceConfig, Datasources};
 use crate::connection::{CANYON_INSTANCE, db_connector, get_canyon_tokio_runtime};
-use db_connector::DatabaseConnection;
+use db_connector::DatabaseConnector;
 use std::collections::HashMap;
 use std::sync::Arc;
 use std::{error::Error, fs};
 use tokio::sync::Mutex;
 
-pub type SharedConnection = Arc<Mutex<DatabaseConnection>>;
+pub type SharedConnection = Arc<Mutex<DatabaseConnector>>;
 
 /// The `Canyon` struct provides the main entry point for interacting with the Canyon-SQL context.
 ///
@@ -53,8 +53,8 @@ pub type SharedConnection = Arc<Mutex<DatabaseConnection>>;
 /// - `get_mut_connection`: Retrieves a mutable connection from the cache.
 pub struct Canyon {
     config: Datasources,
-    connections: HashMap<&'static str, DatabaseConnection>,
-    default_connection: Option<DatabaseConnection>,
+    connections: HashMap<&'static str, DatabaseConnector>,
+    default_connection: Option<DatabaseConnector>,
     default_db_type: Option<DatabaseType>,
 }
 
@@ -112,8 +112,8 @@ impl Canyon {
         let config_content = fs::read_to_string(&path)?;
         let config: Datasources = toml::from_str::<CanyonSqlConfig>(&config_content)?.canyon_sql;
 
-        let mut connections: HashMap<&str, DatabaseConnection> = HashMap::new();
-        let mut default_connection: Option<DatabaseConnection> = None;
+        let mut connections: HashMap<&str, DatabaseConnector> = HashMap::new();
+        let mut default_connection: Option<DatabaseConnector> = None;
         let mut default_db_type: Option<DatabaseType> = None;
 
         for ds in config.datasources.iter() {
@@ -178,7 +178,7 @@ impl Canyon {
     }
 
     // Retrieve a read-only connection from the cache
-    pub fn get_default_connection(&self) -> Result<&DatabaseConnection, DatasourceNotFound> {
+    pub fn get_default_connection(&self) -> Result<&DatabaseConnector, DatasourceNotFound> {
         self.default_connection
             .as_ref()
             .ok_or_else(|| DatasourceNotFound::from(None))
@@ -188,8 +188,8 @@ impl Canyon {
     ///
     /// This is a fast and efficient operation: cloning the [`SharedConnection`]
     /// simply increases the reference count [`Arc`] without duplicating the underlying
-    /// [`DatabaseConnection`]. Returns an error if no default connection is configured.
-    pub fn get_connection(&self, name: &str) -> Result<&DatabaseConnection, DatasourceNotFound> {
+    /// [`DatabaseConnector`]. Returns an error if no default connection is configured.
+    pub fn get_connection(&self, name: &str) -> Result<&DatabaseConnector, DatasourceNotFound> {
         if name.is_empty() {
             return self.get_default_connection();
         }
@@ -207,7 +207,7 @@ impl Canyon {
     pub async fn get_fast_connection(
         &self,
         name: &str,
-    ) -> Result<&DatabaseConnection, DatasourceNotFound> {
+    ) -> Result<&DatabaseConnector, DatasourceNotFound> {
         // For now, fall back to the regular connection
         // In the future, this could automatically use the pool
         self.get_connection(name)
@@ -217,7 +217,7 @@ impl Canyon {
 mod __impl {
     use crate::connection::database_type::DatabaseType;
     use crate::connection::datasources::DatasourceConfig;
-    use crate::connection::db_connector::DatabaseConnection;
+    use crate::connection::db_connector::DatabaseConnector;
     use std::collections::HashMap;
     use std::error::Error;
     use std::path::PathBuf;
@@ -247,15 +247,15 @@ mod __impl {
 
     pub(crate) async fn process_new_conn_by_datasource(
         ds: &DatasourceConfig,
-        connections: &mut HashMap<&str, DatabaseConnection>,
-        default: &mut Option<DatabaseConnection>,
+        connections: &mut HashMap<&str, DatabaseConnector>,
+        default: &mut Option<DatabaseConnector>,
         default_db_type: &mut Option<DatabaseType>,
     ) -> Result<(), Box<dyn Error + Send + Sync>> {
         if default.is_none() {
             let cloned_ds_for_default = ds.clone();
-            *default = Some(DatabaseConnection::new(&cloned_ds_for_default).await?); // Only cloning the smart pointer
+            *default = Some(DatabaseConnector::new(&cloned_ds_for_default).await?); // Only cloning the smart pointer
         }
-        let conn = DatabaseConnection::new(ds).await?;
+        let conn = DatabaseConnector::new(ds).await?;
         let name: &'static str = Box::leak(ds.name.clone().into_boxed_str());
 
         if default_db_type.is_none() {

canyon_core/src/connection/contracts/impl/database_connection.rs

@@ -1,14 +1,14 @@
 use crate::{
     connection::{
-        contracts::DbConnection, database_type::DatabaseType, db_connector::DatabaseConnection,
+        contracts::DbConnection, database_type::DatabaseType, db_connector::DatabaseConnector,
     },
     mapper::RowMapper,
     query::parameters::QueryParameter,
     rows::{CanyonRows, FromSqlOwnedValue},
 };
 use std::error::Error;
 
-impl DbConnection for DatabaseConnection {
+impl DbConnection for DatabaseConnector {
     async fn query_rows(
         &self,
         stmt: &str,
@@ -62,7 +62,7 @@ impl DbConnection for DatabaseConnection {
     }
 }
 
-impl DbConnection for &DatabaseConnection {
+impl DbConnection for &DatabaseConnector {
     async fn query_rows(
         &self,
         stmt: &str,
@@ -116,7 +116,7 @@ impl DbConnection for &DatabaseConnection {
     }
 }
 
-impl DbConnection for &mut DatabaseConnection {
+impl DbConnection for &mut DatabaseConnector {
     async fn query_rows(
         &self,
         stmt: &str,
@@ -171,24 +171,24 @@ impl DbConnection for &mut DatabaseConnection {
 }
 
 pub(crate) async fn db_conn_query_rows_impl<'a>(
-    c: &DatabaseConnection,
+    c: &DatabaseConnector,
     stmt: &str,
     params: &[&'a (dyn QueryParameter + 'a)],
 ) -> Result<CanyonRows, Box<dyn Error + Send + Sync>> {
     match c {
         #[cfg(feature = "postgres")]
-        DatabaseConnection::Postgres(client) => client.query_rows(stmt, params).await,
+        DatabaseConnector::Postgres(client) => client.query_rows(stmt, params).await,
 
         #[cfg(feature = "mssql")]
-        DatabaseConnection::SqlServer(client) => client.query_rows(stmt, params).await,
+        DatabaseConnector::SqlServer(client) => client.query_rows(stmt, params).await,
 
         #[cfg(feature = "mysql")]
-        DatabaseConnection::MySQL(client) => client.query_rows(stmt, params).await,
+        DatabaseConnector::MySQL(client) => client.query_rows(stmt, params).await,
     }
 }
 
 pub(crate) async fn db_conn_query_one_impl<R>(
-    c: &DatabaseConnection,
+    c: &DatabaseConnector,
     stmt: &str,
     params: &[&'_ (dyn QueryParameter + '_)],
 ) -> Result<Option<R::Output>, Box<dyn Error + Send + Sync>>
@@ -197,18 +197,18 @@ where
 {
     match c {
         #[cfg(feature = "postgres")]
-        DatabaseConnection::Postgres(client) => client.query_one::<R>(stmt, params).await,
+        DatabaseConnector::Postgres(client) => client.query_one::<R>(stmt, params).await,
 
         #[cfg(feature = "mssql")]
-        DatabaseConnection::SqlServer(client) => client.query_one::<R>(stmt, params).await,
+        DatabaseConnector::SqlServer(client) => client.query_one::<R>(stmt, params).await,
 
         #[cfg(feature = "mysql")]
-        DatabaseConnection::MySQL(client) => client.query_one::<R>(stmt, params).await,
+        DatabaseConnector::MySQL(client) => client.query_one::<R>(stmt, params).await,
     }
 }
 
 pub(crate) async fn db_conn_query_impl<S, R>(
-    c: &DatabaseConnection,
+    c: &DatabaseConnector,
     stmt: S,
     params: &[&'_ dyn QueryParameter],
 ) -> Result<Vec<R>, Box<dyn Error + Send + Sync>>
@@ -219,18 +219,18 @@ where
 {
     match c {
         #[cfg(feature = "postgres")]
-        DatabaseConnection::Postgres(client) => client.query(stmt, params).await,
+        DatabaseConnector::Postgres(client) => client.query(stmt, params).await,
 
         #[cfg(feature = "mssql")]
-        DatabaseConnection::SqlServer(client) => client.query(stmt, params).await,
+        DatabaseConnector::SqlServer(client) => client.query(stmt, params).await,
 
         #[cfg(feature = "mysql")]
-        DatabaseConnection::MySQL(client) => client.query(stmt, params).await,
+        DatabaseConnector::MySQL(client) => client.query(stmt, params).await,
     }
 }
 
 pub(crate) async fn db_conn_query_one_for_impl<T>(
-    c: &DatabaseConnection,
+    c: &DatabaseConnector,
     stmt: &str,
     params: &[&'_ dyn QueryParameter],
 ) -> Result<T, Box<dyn Error + Send + Sync>>
@@ -239,29 +239,29 @@ where
 {
     match c {
         #[cfg(feature = "postgres")]
-        DatabaseConnection::Postgres(client) => client.query_one_for(stmt, params).await,
+        DatabaseConnector::Postgres(client) => client.query_one_for(stmt, params).await,
 
         #[cfg(feature = "mssql")]
-        DatabaseConnection::SqlServer(client) => client.query_one_for(stmt, params).await,
+        DatabaseConnector::SqlServer(client) => client.query_one_for(stmt, params).await,
 
         #[cfg(feature = "mysql")]
-        DatabaseConnection::MySQL(client) => client.query_one_for(stmt, params).await,
+        DatabaseConnector::MySQL(client) => client.query_one_for(stmt, params).await,
     }
 }
 
 pub(crate) async fn db_conn_execute_impl(
-    c: &DatabaseConnection,
+    c: &DatabaseConnector,
     stmt: &str,
     params: &[&'_ dyn QueryParameter],
 ) -> Result<u64, Box<dyn Error + Send + Sync>> {
     match c {
         #[cfg(feature = "postgres")]
-        DatabaseConnection::Postgres(client) => client.execute(stmt, params).await,
+        DatabaseConnector::Postgres(client) => client.execute(stmt, params).await,
 
         #[cfg(feature = "mssql")]
-        DatabaseConnection::SqlServer(client) => client.execute(stmt, params).await,
+        DatabaseConnector::SqlServer(client) => client.execute(stmt, params).await,
 
         #[cfg(feature = "mysql")]
-        DatabaseConnection::MySQL(client) => client.execute(stmt, params).await,
+        DatabaseConnector::MySQL(client) => client.execute(stmt, params).await,
     }
 }

canyon_core/src/connection/db_connector.rs

@@ -13,7 +13,7 @@ use std::error::Error;
 /// starts, Canyon gets the information about the desired datasources,
 /// process them and generates a pool of 1 to 1 database connection for
 /// every datasource defined.
-pub enum DatabaseConnection {
+pub enum DatabaseConnector {
     // NOTE: is this a Datasource instead of a connection?
     #[cfg(feature = "postgres")]
     Postgres(PostgresConnection),
@@ -23,10 +23,10 @@ pub enum DatabaseConnection {
     MySQL(MySQLConnector),
 }
 
-unsafe impl Send for DatabaseConnection {}
-unsafe impl Sync for DatabaseConnection {}
+unsafe impl Send for DatabaseConnector {}
+unsafe impl Sync for DatabaseConnector {}
 
-impl DatabaseConnection {
+impl DatabaseConnector {
     pub async fn new(datasource: &DatasourceConfig) -> Result<Self, Box<dyn Error + Send + Sync>> {
         // Add connection pooling at the client level for better performance
         match datasource.get_db_type() {
@@ -50,19 +50,19 @@ impl DatabaseConnection {
     pub fn get_db_type(&self) -> DatabaseType {
         match self {
             #[cfg(feature = "postgres")]
-            DatabaseConnection::Postgres(_) => DatabaseType::PostgreSql,
+            DatabaseConnector::Postgres(_) => DatabaseType::PostgreSql,
             #[cfg(feature = "mssql")]
-            DatabaseConnection::SqlServer(_) => DatabaseType::SqlServer,
+            DatabaseConnector::SqlServer(_) => DatabaseType::SqlServer,
             #[cfg(feature = "mysql")]
-            DatabaseConnection::MySQL(_) => DatabaseType::MySQL,
+            DatabaseConnector::MySQL(_) => DatabaseType::MySQL,
         }
     }
 
     /*
         #[cfg(feature = "postgres")]
         pub fn postgres_connection(&self) -> &PostgreSqlConnection {
             match self {
-                DatabaseConnection::Postgres(conn) => conn,
+                DatabaseConnector::Postgres(conn) => conn,
                 #[cfg(any(feature = "mssql", feature = "mysql"))]
                 _ => panic!(),
             }
@@ -71,7 +71,7 @@ impl DatabaseConnection {
         #[cfg(feature = "mssql")]
         pub fn sqlserver_connection(&mut self) -> &mut SqlServerConnection {
             match self {
-                DatabaseConnection::SqlServer(conn) => conn,
+                DatabaseConnector::SqlServer(conn) => conn,
                 #[cfg(any(feature = "postgres", feature = "mysql"))]
                 _ => panic!(),
             }
@@ -80,7 +80,7 @@ impl DatabaseConnection {
         #[cfg(feature = "mysql")]
         pub fn mysql_connection(&self) -> &MysqlConnection {
             match self {
-                DatabaseConnection::MySQL(conn) => conn,
+                DatabaseConnector::MySQL(conn) => conn,
                 #[cfg(any(feature = "postgres", feature = "mssql"))]
                 _ => panic!(),
             }

canyon_core/src/connection/mod.rs

@@ -36,7 +36,7 @@ type MsManager = TiberiusConnectionManager;
 type SqlServerConnectionPool = Arc<bb8::Pool<MsManager>>;
 
 //
-// // TODO's: DatabaseConnection and DataSource can implement default, so there's no need to use str and &str
+// // TODO's: DatabaseConnector and DataSource can implement default, so there's no need to use str and &str
 // // as defaults anymore, since the can load as the default the first one defined in the config file, or have more
 // // complex workflows that are deferred to initialization time
 //

canyon_core/src/connection/provisional_tests.rs

@@ -6,7 +6,7 @@
 // mod connection_tests {
 //     use tokio;
 //     use super::connection_helpers::*;
-//     use crate::{db_connector::DatabaseConnection, datasources::{Auth, DatasourceConfig, DatasourceProperties, PostgresAuth}};
+//     use crate::{db_connector::DatabaseConnector, datasources::{Auth, DatasourceConfig, DatasourceProperties, PostgresAuth}};
 
 //     #[tokio::test]
 //     #[cfg(feature = "postgres")]
@@ -97,7 +97,7 @@
 //                 },
 //             };
 
-//             let result = DatabaseConnection::new(&config).await;
+//             let result = DatabaseConnector::new(&config).await;
 //             assert!(result.is_ok());
 //         }
 
@@ -116,7 +116,7 @@
 //         //         },
 //         //     };
 
-//         //     let result = DatabaseConnection::new(&config).await;
+//         //     let result = DatabaseConnector::new(&config).await;
 //         //     assert!(result.is_ok());
 //         // }
 
@@ -135,7 +135,7 @@
 //         //         },
 //         //     };
 
-//         //     let result = DatabaseConnection::new(&config).await;
+//         //     let result = DatabaseConnector::new(&config).await;
 //         //     assert!(result.is_ok());
 //         // }
 //     }

canyon_migrations/src/migrations/handler.rs

@@ -10,7 +10,7 @@ use crate::{
 use canyon_core::canyon::Canyon;
 use canyon_core::{
     column::Column,
-    connection::db_connector::DatabaseConnection,
+    connection::db_connector::DatabaseConnector,
     row::{Row, RowOperations},
     rows::CanyonRows,
     transaction::Transaction,
@@ -91,7 +91,7 @@ impl Migrations {
     /// chosen by its datasource name property
     async fn fetch_database(
         ds_name: &str,
-        db_conn: &DatabaseConnection,
+        db_conn: &DatabaseConnector,
         db_type: DatabaseType,
     ) -> CanyonRows {
         let query = match db_type {

canyon_migrations/src/migrations/memory.rs

@@ -1,7 +1,7 @@
 use crate::constants;
 use canyon_core::canyon::Canyon;
 use canyon_core::connection::contracts::DbConnection;
-use canyon_core::connection::db_connector::DatabaseConnection;
+use canyon_core::connection::db_connector::DatabaseConnector;
 use canyon_core::transaction::Transaction;
 use canyon_crud::{DatabaseType, DatasourceConfig};
 use regex::Regex;
@@ -262,7 +262,7 @@ impl CanyonMemory {
     /// Generates, if not exists the `canyon_memory` table
     async fn create_memory(
         datasource_name: &str,
-        db_conn: &DatabaseConnection,
+        db_conn: &DatabaseConnector,
         database_type: &DatabaseType,
     ) {
         let query = match database_type {

src/lib.rs

@@ -30,7 +30,7 @@ pub mod macros {
 pub mod connection {
     pub use canyon_core::connection::contracts::DbConnection;
     pub use canyon_core::connection::database_type::DatabaseType;
-    pub use canyon_core::connection::db_connector::DatabaseConnection;
+    pub use canyon_core::connection::db_connector::DatabaseConnector;
 }
 
 pub mod core {