Allow creating a sea_orm::Databse from sqlx::ConnectOptions

Author: 05storm26

Cargo.toml

@@ -34,7 +34,7 @@ sea-query = { version = "^0.20.0", features = ["thread-safe"] }
 sea-strum = { version = "^0.21", features = ["derive", "sea-orm"] }
 serde = { version = "^1.0", features = ["derive"] }
 serde_json = { version = "^1", optional = true }
-sqlx = { version = "^0.5", optional = true }
+sqlx = { version = "^0.5.11", optional = true }
 uuid = { version = "0.8", features = ["serde", "v4"], optional = true }
 ouroboros = "0.14"
 url = "^2.2"
@@ -68,13 +68,14 @@ with-json = ["serde_json", "sea-query/with-json", "chrono/serde"]
 with-chrono = ["chrono", "sea-query/with-chrono"]
 with-rust_decimal = ["rust_decimal", "sea-query/with-rust_decimal"]
 with-uuid = ["uuid", "sea-query/with-uuid"]
-sqlx-all = ["sqlx-mysql", "sqlx-postgres", "sqlx-sqlite"]
+sqlx-all = ["sqlx-mysql", "sqlx-postgres", "sqlx-sqlite", "sqlx-any"]
 sqlx-dep = ["sqlx-json", "sqlx-chrono", "sqlx-decimal", "sqlx-uuid"]
 sqlx-json = ["sqlx/json", "with-json"]
 sqlx-chrono = ["sqlx/chrono", "with-chrono"]
 sqlx-decimal = ["sqlx/decimal", "with-rust_decimal"]
 sqlx-uuid = ["sqlx/uuid", "with-uuid"]
 sqlx-mysql = ["sqlx-dep", "sea-query/sqlx-mysql", "sqlx/mysql"]
+sqlx-any = ["sqlx-dep", "sqlx/any"]
 sqlx-postgres = ["sqlx-dep", "sea-query/sqlx-postgres", "sqlx/postgres"]
 sqlx-sqlite = ["sqlx-dep", "sea-query/sqlx-sqlite", "sqlx/sqlite"]
 runtime-async-std = []

src/database/mod.rs

@@ -1,3 +1,12 @@
+#[cfg(feature = "sqlx-any")]
+use sqlx::any::AnyKind;
+#[cfg(feature = "sqlx-mysql")]
+use sqlx::mysql::MySqlConnectOptions;
+#[cfg(feature = "sqlx-postgres")]
+use sqlx::postgres::PgConnectOptions;
+#[cfg(feature = "sqlx-sqlite")]
+use sqlx::sqlite::SqliteConnectOptions;
+use std::fmt::Debug;
 use std::time::Duration;
 
 mod connection;
@@ -23,11 +32,55 @@ use crate::DbErr;
 #[derive(Debug, Default)]
 pub struct Database;
 
+/// Supported database kinds of [sqlx::ConnectOptions]'.
+#[derive(Debug, Clone)]
+pub enum SqlxConnectOptions {
+    #[cfg(feature = "sqlx-mysql")]
+    MySql(MySqlConnectOptions),
+    #[cfg(feature = "sqlx-postgres")]
+    Postgres(PgConnectOptions),
+    #[cfg(feature = "sqlx-sqlite")]
+    Sqlite(SqliteConnectOptions),
+    #[cfg(feature = "mock")]
+    Mock(DbBackend),
+}
+
+impl SqlxConnectOptions {
+    /// The database backend type
+    pub fn get_db_backend_type(&self) -> DbBackend {
+        match self {
+            #[cfg(feature = "sqlx-mysql")]
+            SqlxConnectOptions::MySql(_) => DbBackend::MySql,
+            #[cfg(feature = "sqlx-postgres")]
+            SqlxConnectOptions::Postgres(_) => DbBackend::Postgres,
+            #[cfg(feature = "sqlx-sqlite")]
+            SqlxConnectOptions::Sqlite(_) => DbBackend::Sqlite,
+            #[cfg(feature = "mock")]
+            SqlxConnectOptions::Mock(db_backend) => db_backend.clone(),
+        }
+    }
+
+    #[cfg(feature = "mock")]
+    pub fn mock(db_backend: DbBackend) -> SqlxConnectOptions {
+        Self::Mock(db_backend)
+    }
+
+    #[cfg(feature = "mock")]
+    pub fn is_mock(&self) -> bool {
+        match self {
+            SqlxConnectOptions::Mock(_) => true,
+            _ => false,
+        }
+    }
+}
+
 /// Defines the configuration options of a database
 #[derive(Debug)]
 pub struct ConnectOptions {
-    /// The URI of the database
-    pub(crate) url: String,
+    /// The database sqlx::ConnectOptions used to connect to the database.
+    pub(crate) connect_options: SqlxConnectOptions,
+    /// The URI of the database, if this struct was created from an URI string, otherwise None
+    pub(crate) url: Option<String>,
     /// Maximum number of connections for a pool
     pub(crate) max_connections: Option<u32>,
     /// Minimum number of connections for a pool
@@ -44,58 +97,165 @@ pub struct ConnectOptions {
 impl Database {
     /// Method to create a [DatabaseConnection] on a database
     #[instrument(level = "trace", skip(opt))]
-    pub async fn connect<C>(opt: C) -> Result<DatabaseConnection, DbErr>
+    pub async fn connect<C, E>(opt: C) -> Result<DatabaseConnection, DbErr>
     where
-        C: Into<ConnectOptions>,
+        C: TryInto<ConnectOptions, Error = E> + Debug,
+        E: std::error::Error,
     {
-        let opt: ConnectOptions = opt.into();
+        let describe = format!("{:?}", opt);
+        let opt: ConnectOptions = opt
+            .try_into()
+            .map_err(|e| DbErr::Conn(format!("Couldn't parse connection options {}", e)))?;
 
-        #[cfg(feature = "sqlx-mysql")]
-        if DbBackend::MySql.is_prefix_of(&opt.url) {
-            return crate::SqlxMySqlConnector::connect(opt).await;
-        }
-        #[cfg(feature = "sqlx-postgres")]
-        if DbBackend::Postgres.is_prefix_of(&opt.url) {
-            return crate::SqlxPostgresConnector::connect(opt).await;
-        }
-        #[cfg(feature = "sqlx-sqlite")]
-        if DbBackend::Sqlite.is_prefix_of(&opt.url) {
-            return crate::SqlxSqliteConnector::connect(opt).await;
-        }
         #[cfg(feature = "mock")]
-        if crate::MockDatabaseConnector::accepts(&opt.url) {
-            return crate::MockDatabaseConnector::connect(&opt.url).await;
+        if opt.connect_options.is_mock() {
+            return crate::MockDatabaseConnector::connect(opt).await;
+        }
+
+        let backend = opt.connect_options.get_db_backend_type();
+
+        match backend {
+            #[cfg(feature = "sqlx-mysql")]
+            DbBackend::MySql => crate::SqlxMySqlConnector::connect(opt).await,
+            #[cfg(feature = "sqlx-postgres")]
+            DbBackend::Postgres => crate::SqlxPostgresConnector::connect(opt).await,
+            #[cfg(feature = "sqlx-sqlite")]
+            DbBackend::Sqlite => crate::SqlxSqliteConnector::connect(opt).await,
+            _ => {
+                return Err(DbErr::Conn(format!(
+                    "The connection option {} has no supporting driver.",
+                    describe
+                )));
+            }
         }
-        Err(DbErr::Conn(format!(
-            "The connection string '{}' has no supporting driver.",
-            opt.url
-        )))
     }
 }
 
-impl From<&str> for ConnectOptions {
-    fn from(string: &str) -> ConnectOptions {
+impl TryFrom<&str> for ConnectOptions {
+    type Error = DbErr;
+
+    fn try_from(string: &str) -> Result<Self, Self::Error> {
         ConnectOptions::from_str(string)
     }
 }
 
-impl From<&String> for ConnectOptions {
-    fn from(string: &String) -> ConnectOptions {
+impl TryFrom<&String> for ConnectOptions {
+    type Error = DbErr;
+
+    fn try_from(string: &String) -> Result<Self, Self::Error> {
         ConnectOptions::from_str(string.as_str())
     }
 }
 
-impl From<String> for ConnectOptions {
-    fn from(string: String) -> ConnectOptions {
-        ConnectOptions::new(string)
+impl TryFrom<String> for ConnectOptions {
+    type Error = DbErr;
+
+    fn try_from(string: String) -> Result<Self, Self::Error> {
+        ConnectOptions::new_from_url(string)
+    }
+}
+
+#[cfg(feature = "sqlx-mysql")]
+impl TryFrom<MySqlConnectOptions> for ConnectOptions {
+    type Error = DbErr;
+
+    fn try_from(connect_options: MySqlConnectOptions) -> Result<Self, Self::Error> {
+        Ok(ConnectOptions::new(SqlxConnectOptions::MySql(
+            connect_options,
+        )))
+    }
+}
+
+#[cfg(feature = "sqlx-postgres")]
+impl TryFrom<PgConnectOptions> for ConnectOptions {
+    type Error = DbErr;
+
+    fn try_from(connect_options: PgConnectOptions) -> Result<Self, Self::Error> {
+        Ok(ConnectOptions::new(SqlxConnectOptions::Postgres(
+            connect_options,
+        )))
+    }
+}
+
+#[cfg(feature = "sqlx-sqlite")]
+impl TryFrom<SqliteConnectOptions> for ConnectOptions {
+    type Error = DbErr;
+
+    fn try_from(connect_options: SqliteConnectOptions) -> Result<Self, Self::Error> {
+        Ok(ConnectOptions::new(SqlxConnectOptions::Sqlite(
+            connect_options,
+        )))
+    }
+}
+
+#[cfg(feature = "sqlx-any")]
+impl TryFrom<sqlx::any::AnyConnectOptions> for ConnectOptions {
+    type Error = DbErr;
+
+    fn try_from(connect_options: sqlx::any::AnyConnectOptions) -> Result<Self, Self::Error> {
+        Ok(ConnectOptions::new(connect_options.try_into()?))
+    }
+}
+
+#[cfg(feature = "sqlx-mysql")]
+impl TryFrom<MySqlConnectOptions> for SqlxConnectOptions {
+    type Error = DbErr;
+
+    fn try_from(connect_options: MySqlConnectOptions) -> Result<Self, Self::Error> {
+        Ok(SqlxConnectOptions::MySql(connect_options))
+    }
+}
+
+#[cfg(feature = "sqlx-postgres")]
+impl TryFrom<PgConnectOptions> for SqlxConnectOptions {
+    type Error = DbErr;
+
+    fn try_from(connect_options: PgConnectOptions) -> Result<Self, Self::Error> {
+        Ok(SqlxConnectOptions::Postgres(connect_options))
+    }
+}
+
+#[cfg(feature = "sqlx-sqlite")]
+impl TryFrom<SqliteConnectOptions> for SqlxConnectOptions {
+    type Error = DbErr;
+
+    fn try_from(connect_options: SqliteConnectOptions) -> Result<Self, Self::Error> {
+        Ok(SqlxConnectOptions::Sqlite(connect_options))
+    }
+}
+
+#[cfg(feature = "sqlx-any")]
+impl TryFrom<sqlx::any::AnyConnectOptions> for SqlxConnectOptions {
+    type Error = DbErr;
+
+    fn try_from(connect_options: sqlx::any::AnyConnectOptions) -> Result<Self, Self::Error> {
+        match connect_options.kind() {
+            #[cfg(feature = "sqlx-postgres")]
+            AnyKind::Postgres => Ok(SqlxConnectOptions::Postgres(
+                connect_options.as_postgres_cloned().unwrap(),
+            )),
+            #[cfg(feature = "sqlx-mysql")]
+            AnyKind::MySql => Ok(SqlxConnectOptions::MySql(
+                connect_options.as_mysql_cloned().unwrap(),
+            )),
+            #[cfg(feature = "sqlx-sqlite")]
+            AnyKind::Sqlite => Ok(SqlxConnectOptions::Sqlite(
+                connect_options.as_sqlite_cloned().unwrap(),
+            )),
+            _ => Err(DbErr::Conn(format!(
+                "Sea orm doesn't support sqlx database kind: {:?}!",
+                connect_options.kind()
+            ))),
+        }
     }
 }
 
 impl ConnectOptions {
-    /// Create new [ConnectOptions] for a [Database] by passing in a URI string
-    pub fn new(url: String) -> Self {
+    /// Create new [ConnectOptions] for a [Database] by passing in a [sqlx::ConnectOptions]
+    pub fn new(connect_options: SqlxConnectOptions) -> Self {
         Self {
-            url,
+            connect_options,
+            url: None,
             max_connections: None,
             min_connections: None,
             connect_timeout: None,
@@ -104,8 +264,64 @@ impl ConnectOptions {
         }
     }
 
-    fn from_str(url: &str) -> Self {
-        Self::new(url.to_owned())
+    /// Create new [ConnectOptions] for a [Database] by passing in a URI string
+    pub fn new_from_url(url: String) -> Result<Self, DbErr> {
+        Ok(Self {
+            connect_options: Self::url_to_sqlx_connect_options(url.clone())?,
+            url: Some(url),
+            max_connections: None,
+            min_connections: None,
+            connect_timeout: None,
+            idle_timeout: None,
+            sqlx_logging: true,
+        })
+    }
+
+    fn url_to_sqlx_connect_options(url: String) -> Result<SqlxConnectOptions, DbErr> {
+        #[cfg(feature = "sqlx-mysql")]
+        if DbBackend::MySql.is_prefix_of(&url) {
+            return Ok(url
+                .parse::<MySqlConnectOptions>()
+                .map_err(|e| DbErr::Conn(e.to_string()))?
+                .try_into()?);
+        }
+        #[cfg(feature = "sqlx-postgres")]
+        if DbBackend::Postgres.is_prefix_of(&url) {
+            return Ok(url
+                .parse::<PgConnectOptions>()
+                .map_err(|e| DbErr::Conn(e.to_string()))?
+                .try_into()?);
+        }
+        #[cfg(feature = "sqlx-sqlite")]
+        if DbBackend::Sqlite.is_prefix_of(&url) {
+            return Ok(url
+                .parse::<SqliteConnectOptions>()
+                .map_err(|e| DbErr::Conn(e.to_string()))?
+                .try_into()?);
+        }
+        #[cfg(feature = "mock")]
+        if crate::MockDatabaseConnector::accepts(&url) {
+            if DbBackend::MySql.is_prefix_of(&url) {
+                return Ok(SqlxConnectOptions::Mock(DbBackend::MySql));
+            }
+            #[cfg(feature = "sqlx-postgres")]
+            if DbBackend::Postgres.is_prefix_of(&url) {
+                return Ok(SqlxConnectOptions::Mock(DbBackend::Postgres));
+            }
+            #[cfg(feature = "sqlx-sqlite")]
+            if DbBackend::Sqlite.is_prefix_of(&url) {
+                return Ok(SqlxConnectOptions::Mock(DbBackend::Sqlite));
+            }
+            return Ok(SqlxConnectOptions::Mock(DbBackend::Postgres));
+        }
+        Err(DbErr::Conn(format!(
+            "The connection string '{}' has no supporting driver.",
+            url
+        )))
+    }
+
+    fn from_str(url: &str) -> Result<Self, DbErr> {
+        Self::new_from_url(url.to_owned())
     }
 
     #[cfg(feature = "sqlx-dep")]
@@ -130,11 +346,19 @@ impl ConnectOptions {
         opt
     }
 
-    /// Get the database URL of the pool
-    pub fn get_url(&self) -> &str {
+    /// Get the database URL of the pool. This is only present if the pool was created from an URL.
+    /// If it was created from some sqlx::ConnectOptions then this method returns None.
+    ///
+    /// To get the actual ConnectOptions used to connect to the database see: [Self::get_connect_options].
+    pub fn get_url(&self) -> &Option<String> {
         &self.url
     }
 
+    /// Get the ConnectOptions used to connect to the database
+    pub fn get_connect_options(&self) -> &SqlxConnectOptions {
+        &self.connect_options
+    }
+
     /// Set the maximum number of connections of the pool
     pub fn max_connections(&mut self, value: u32) -> &mut Self {
         self.max_connections = Some(value);