@deterministic-code/migraters 0.0.3 → 0.0.5

package/rust/{dialects → providers}/sqlite/Cargo.toml

@@ -7,5 +7,6 @@ edition = "2021"
 async-trait = "0.1"
 inventory = "0.3"
 migraters-api = { path = "../../api" }
+migraters-sql = { path = "../sql" }
 sqlx = { version = "0.8", default-features = false, features = ["runtime-tokio", "sqlite"] }
 tokio = { version = "1", features = ["rt"] }

package/rust/{dialects → providers}/sqlite/src/lib.rs

@@ -3,13 +3,14 @@ use std::future::Future;
 use std::pin::Pin;
 
 use async_trait::async_trait;
-use migraters_api::{catalog_name, BoxError, DialectPlugin, MigrationSession, SqlDialect};
+use migraters_api::{catalog_name, BoxError, DialectPlugin, IDatasourceProvider, MigrationDriver};
+use migraters_sql::{sqlite_filesystem_path, SqlDriver, SqlSession};
 use sqlx::sqlite::SqlitePool;
 use sqlx::Row;
 
-pub struct SqliteDialect;
+pub struct SqliteProvider;
 
-pub static SQLITE: SqliteDialect = SqliteDialect;
+pub static SQLITE: SqliteProvider = SqliteProvider;
 
 inventory::submit! {
     DialectPlugin { dialect: &SQLITE }
@@ -18,7 +19,7 @@ inventory::submit! {
 const SQLITE_PREREQ: &str =
     include_str!("../../../../shared/templates/messages/errors/sqlite-prerequisite.txt");
 
-impl SqlDialect for SqliteDialect {
+impl IDatasourceProvider for SqliteProvider {
     fn name(&self) -> &'static str {
         "sqlite"
     }
@@ -48,14 +49,14 @@ impl SqlDialect for SqliteDialect {
         }
     }
     fn prerequisite_error(&self, connection: &str) -> Option<String> {
-        let path = filesystem_path(connection)?;
+        let path = sqlite_filesystem_path(connection)?;
         if std::path::Path::new(&path).exists() {
             return None;
         }
         Some(SQLITE_PREREQ.replace("{{path}}", &path))
     }
     fn prepare_setup(&self, connection: &str) -> std::io::Result<()> {
-        if let Some(path) = filesystem_path(connection) {
+        if let Some(path) = sqlite_filesystem_path(connection) {
             if let Some(parent) = std::path::Path::new(&path).parent() {
                 if !parent.as_os_str().is_empty() {
                     std::fs::create_dir_all(parent)?;
@@ -67,11 +68,12 @@ impl SqlDialect for SqliteDialect {
     fn connect<'a>(
         &'a self,
         connection: &'a str,
-    ) -> Pin<Box<dyn Future<Output = Result<Box<dyn MigrationSession>, BoxError>> + Send + 'a>> {
+    ) -> Pin<Box<dyn Future<Output = Result<Box<dyn MigrationDriver>, BoxError>> + Send + 'a>> {
         Box::pin(async move {
             let url = self.normalize_connection(connection);
             let pool = SqlitePool::connect(&url).await?;
-            Ok(Box::new(SqliteSession { pool }) as Box<dyn MigrationSession>)
+            Ok(Box::new(SqlDriver::wrap(SqliteSession { pool }, &SQLITE))
+                as Box<dyn MigrationDriver>)
         })
     }
 }
@@ -81,7 +83,7 @@ struct SqliteSession {
 }
 
 #[async_trait]
-impl MigrationSession for SqliteSession {
+impl SqlSession for SqliteSession {
     async fn execute(&self, sql: &str) -> Result<(), BoxError> {
         sqlx::query(sql).execute(&self.pool).await?;
         Ok(())
@@ -183,36 +185,14 @@ async fn catalog_exec_pool(
     Ok(())
 }
 
-fn filesystem_path(connection: &str) -> Option<String> {
-    let mut s = connection.trim().to_string();
-    if let Some(eq) = s.find('=') {
-        let key = s[..eq].trim().to_ascii_lowercase();
-        if key.replace(' ', "") == "datasource" {
-            s = s[eq + 1..].trim().to_string();
-        }
-    }
-    let lower = s.to_ascii_lowercase();
-    if lower.starts_with("sqlite://") {
-        s = s["sqlite://".len()..].to_string();
-    } else if lower.starts_with("sqlite:") {
-        s = s["sqlite:".len()..].to_string();
-    } else if lower.starts_with("file:") {
-        s = s["file:".len()..].to_string();
-    }
-    if s == ":memory:" || s.is_empty() {
-        return None;
-    }
-    Some(s)
-}
-
 #[cfg(test)]
 mod tests {
-    use super::SqliteDialect;
-    use migraters_api::{assert_dialect_surface, SqlDialect};
+    use super::SqliteProvider;
+    use migraters_api::{assert_dialect_surface, IDatasourceProvider};
 
     #[test]
     fn surface_and_path_parsing() {
-        let d = SqliteDialect;
+        let d = SqliteProvider;
         assert_dialect_surface(&d);
         assert_eq!(d.name(), "sqlite");
         assert_eq!(d.connection_env_vars(), &["SQLITE_PATH", "DB_PATH"]);
@@ -239,11 +219,24 @@ mod tests {
         assert!(d.prerequisite_error("file:").is_none());
         assert!(d.prerequisite_error("Data Source=:memory:").is_none());
         assert!(d.prerequisite_error("data source = :memory:").is_none());
+        assert!(d
+            .prerequisite_error("sqlite://file:migraters-test?mode=memory&cache=shared")
+            .is_none());
+        assert!(d
+            .prerequisite_error("Data Source=migraters-test;Mode=Memory;Cache=Shared")
+            .is_none());
         assert!(d.prerequisite_error("SQLITE://").is_none());
         assert!(d.prerequisite_error("FILE:").is_none());
         d.prepare_setup(":memory:").unwrap();
-        d.prepare_setup("app.sqlite").unwrap();
+        d.prepare_setup("sqlite://file:migraters-test?mode=memory&cache=shared")
+            .unwrap();
         d.prepare_setup("/").unwrap();
+    }
+
+    #[test]
+    fn file_path_io() {
+        let d = SqliteProvider;
+        d.prepare_setup("app.sqlite").unwrap();
 
         let dir = std::env::temp_dir().join(format!(
             "migraters-sqlite-paths-{}",