@deterministic-code/migraters 0.0.4 → 0.0.5

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

@@ -7,6 +7,7 @@ edition = "2021"
 async-trait = "0.1"
 inventory = "0.3"
 migraters-api = { path = "../../api" }
+migraters-sql = { path = "../sql" }
 tiberius = { version = "0.12", default-features = false, features = ["tds73", "chrono", "rustls"] }
 tokio = { version = "1", features = ["io-util", "net", "rt"] }
 tokio-util = { version = "0.7", features = ["compat"] }

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

@@ -3,7 +3,8 @@ 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::{SqlDriver, SqlSession};
 use tiberius::{Client, Config};
 use tokio::net::TcpStream;
 use tokio::sync::Mutex;
@@ -11,15 +12,15 @@ use tokio_util::compat::{Compat, TokioAsyncWriteCompatExt};
 
 type MssqlClient = Client<Compat<TcpStream>>;
 
-pub struct SqlServerDialect;
+pub struct SqlServerProvider;
 
-pub static SQLSERVER: SqlServerDialect = SqlServerDialect;
+pub static SQLSERVER: SqlServerProvider = SqlServerProvider;
 
 inventory::submit! {
     DialectPlugin { dialect: &SQLSERVER }
 }
 
-impl SqlDialect for SqlServerDialect {
+impl IDatasourceProvider for SqlServerProvider {
     fn name(&self) -> &'static str {
         "sqlserver"
     }
@@ -62,7 +63,7 @@ impl SqlDialect for SqlServerDialect {
     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 config = Config::from_ado_string(&url)
@@ -71,9 +72,12 @@ impl SqlDialect for SqlServerDialect {
             let tcp = TcpStream::connect(config.get_addr()).await?;
             tcp.set_nodelay(true)?;
             let client = Client::connect(config, tcp.compat_write()).await?;
-            Ok(Box::new(SqlServerSession {
-                client: Mutex::new(client),
-            }) as Box<dyn MigrationSession>)
+            Ok(Box::new(SqlDriver::wrap(
+                SqlServerSession {
+                    client: Mutex::new(client),
+                },
+                &SQLSERVER,
+            )) as Box<dyn MigrationDriver>)
         })
     }
     fn create_database<'a>(
@@ -89,7 +93,7 @@ struct SqlServerSession {
 }
 
 #[async_trait]
-impl MigrationSession for SqlServerSession {
+impl SqlSession for SqlServerSession {
     async fn execute(&self, sql: &str) -> Result<(), BoxError> {
         let mut c = self.client.lock().await;
         c.execute(sql, &[]).await?;
@@ -210,12 +214,12 @@ async fn create_database(connection: &str) -> Result<(), BoxError> {
 
 #[cfg(test)]
 mod tests {
-    use super::SqlServerDialect;
-    use migraters_api::{assert_dialect_surface, SqlDialect};
+    use super::SqlServerProvider;
+    use migraters_api::{assert_dialect_surface, IDatasourceProvider};
 
     #[test]
     fn surface() {
-        let d = SqlServerDialect;
+        let d = SqlServerProvider;
         assert_dialect_surface(&d);
         assert_eq!(d.name(), "sqlserver");
         assert_eq!(d.connection_env_vars(), &["MSSQL_URL", "DATABASE_URL"]);

package/rust/src/abstractions/factory.rs

@@ -1,17 +1,41 @@
+use std::sync::OnceLock;
+
+use crate::migraters_config;
 use crate::provider::normalize_provider;
 use migraters_api::registered_dialects;
 
-use super::SqlDialect;
+use super::Dialect;
+
+fn enabled() -> &'static [&'static dyn Dialect] {
+    static ENABLED: OnceLock<Vec<&'static dyn Dialect>> = OnceLock::new();
+    ENABLED
+        .get_or_init(|| {
+            let registered = registered_dialects();
+            migraters_config::enabled_providers()
+                .into_iter()
+                .map(|entry| {
+                    let name = normalize_provider(&entry.name).unwrap_or(entry.name.as_str());
+                    registered
+                        .iter()
+                        .copied()
+                        .find(|dialect| dialect.name() == name)
+                        .unwrap_or_else(|| panic!("{name}"))
+                })
+                .collect()
+        })
+        .as_slice()
+}
 
-pub fn try_get(name: &str) -> Option<&'static dyn SqlDialect> {
+pub fn try_get(name: &str) -> Option<&'static dyn Dialect> {
     let key = normalize_provider(name)?;
-    registered_dialects()
-        .into_iter()
+    enabled()
+        .iter()
+        .copied()
         .find(|dialect| dialect.name() == key)
 }
 
-pub fn all() -> Vec<&'static dyn SqlDialect> {
-    let mut dialects = registered_dialects();
+pub fn all() -> Vec<&'static dyn Dialect> {
+    let mut dialects = enabled().to_vec();
     dialects.sort_by_key(|dialect| dialect.name());
     dialects
 }

package/rust/src/abstractions/mod.rs

@@ -2,4 +2,4 @@ mod factory;
 mod sql_dialect;
 
 pub use factory::{all, try_get};
-pub use sql_dialect::SqlDialect;
+pub use sql_dialect::{Dialect, IDatasourceProvider, SqlDialect};

package/rust/src/abstractions/sql_dialect.rs

@@ -1 +1 @@
-pub use migraters_api::SqlDialect;
+pub use migraters_api::{Dialect, IDatasourceProvider, SqlDialect};

package/rust/src/attached_dialects.rs

@@ -1,2 +1,2 @@
-// migrate-init attaches selected dialect crates here.
+// Generated by migrate-init. Do not edit.
 #![allow(unused_imports)]

package/rust/src/infrastructure/pool.rs

@@ -1,9 +1,8 @@
 use std::collections::HashMap;
+use std::sync::atomic::{AtomicBool, Ordering};
 
-use crate::abstractions::SqlDialect;
-use migraters_api::{
-    apply_statements, insert_log_started, update_log, BoxError as ApiError, MigrationSession,
-};
+use crate::abstractions::Dialect;
+use migraters_api::BoxError as ApiError;
 
 type BoxError = Box<dyn std::error::Error>;
 
@@ -12,68 +11,128 @@ fn cast(err: ApiError) -> BoxError {
 }
 
 pub struct MigrationPool {
-    session: Box<dyn MigrationSession>,
+    dialect: &'static dyn Dialect,
+    connection: String,
+    setup_started: AtomicBool,
 }
 
 impl MigrationPool {
-    pub async fn connect(dialect: &dyn SqlDialect, connection: &str) -> Result<Self, BoxError> {
+    pub async fn connect(dialect: &'static dyn Dialect, connection: &str) -> Result<Self, BoxError> {
         Ok(Self {
-            session: dialect.connect(connection).await.map_err(cast)?,
+            dialect,
+            connection: connection.to_string(),
+            setup_started: AtomicBool::new(false),
         })
     }
 
-    pub async fn execute(&self, sql: &str) -> Result<(), BoxError> {
-        self.session.execute(sql).await.map_err(cast)
+    pub async fn setup(&self) -> Result<(), BoxError> {
+        self.dialect.setup(&self.connection).await.map_err(cast)
+    }
+
+    pub async fn execute(&self, _sql: &str) -> Result<(), BoxError> {
+        if self
+            .setup_started
+            .compare_exchange(false, true, Ordering::SeqCst, Ordering::SeqCst)
+            .is_ok()
+        {
+            self.dialect.setup(&self.connection).await.map_err(cast)?;
+        }
+        Ok(())
     }
 
     pub async fn fetch_applied(
         &self,
-        sql: &str,
+        _sql: &str,
     ) -> Result<HashMap<String, Option<String>>, BoxError> {
-        self.session.fetch_applied(sql).await.map_err(cast)
+        self.applied().await
+    }
+
+    pub async fn applied(&self) -> Result<HashMap<String, Option<String>>, BoxError> {
+        self.dialect.applied(&self.connection).await.map_err(cast)
     }
 
     pub async fn apply_statements(
         &self,
-        dialect: &dyn SqlDialect,
+        _dialect: &dyn Dialect,
         sql: &str,
         catalog_sql: &str,
         p1: &str,
         p2: Option<&str>,
     ) -> Result<(), BoxError> {
-        apply_statements(&*self.session, dialect, sql, catalog_sql, p1, p2)
+        if catalog_sql.to_ascii_uppercase().contains("DELETE") {
+            self.dialect
+                .migrate_down(&self.connection, p1, sql)
+                .await
+                .map_err(cast)
+        } else {
+            self.dialect
+                .migrate_up(&self.connection, p1, sql, p2.unwrap_or(""))
+                .await
+                .map_err(cast)
+        }
+    }
+
+    pub async fn migrate_up(&self, name: &str, body: &str, checksum: &str) -> Result<(), BoxError> {
+        self.dialect
+            .migrate_up(&self.connection, name, body, checksum)
+            .await
+            .map_err(cast)
+    }
+
+    pub async fn migrate_down(&self, name: &str, body: &str) -> Result<(), BoxError> {
+        self.dialect
+            .migrate_down(&self.connection, name, body)
             .await
             .map_err(cast)
     }
 
     pub async fn insert_log_started(
         &self,
-        dialect: &dyn SqlDialect,
+        _dialect: &dyn Dialect,
         name: &str,
         direction: &str,
     ) -> Result<i64, BoxError> {
-        insert_log_started(&*self.session, dialect, name, direction)
+        self.log_started(name, direction).await
+    }
+
+    pub async fn log_started(&self, name: &str, direction: &str) -> Result<i64, BoxError> {
+        self.dialect
+            .log(&self.connection, None, name, direction, None, 0, None)
             .await
             .map_err(cast)
     }
 
     pub async fn update_log(
         &self,
-        dialect: &dyn SqlDialect,
+        _dialect: &dyn Dialect,
         id: i64,
         status: &str,
         duration_ms: i64,
         error_message: Option<&str>,
     ) -> Result<(), BoxError> {
-        update_log(
-            &*self.session,
-            dialect,
-            id,
-            status,
-            duration_ms,
-            error_message,
-        )
-        .await
-        .map_err(cast)
+        self.log_finished(id, status, duration_ms, error_message)
+            .await
+    }
+
+    pub async fn log_finished(
+        &self,
+        id: i64,
+        status: &str,
+        duration_ms: i64,
+        error_message: Option<&str>,
+    ) -> Result<(), BoxError> {
+        self.dialect
+            .log(
+                &self.connection,
+                Some(id),
+                "",
+                "",
+                Some(status),
+                duration_ms,
+                error_message,
+            )
+            .await
+            .map_err(cast)?;
+        Ok(())
     }
 }

package/rust/src/lib.rs

@@ -1,17 +1,17 @@
-mod attached_dialects;
 pub mod abstractions;
 pub mod argv;
+mod attached_dialects;
 pub mod checksum;
 pub mod cli_spec;
-pub mod dialects;
 pub mod help;
 pub mod infrastructure;
 pub mod messages;
 pub mod migrater;
+pub mod migraters_config;
 pub mod migrations;
 pub mod provider;
 
-pub use abstractions::{all, try_get, SqlDialect};
+pub use abstractions::{all, try_get, Dialect, IDatasourceProvider, SqlDialect};
 pub use argv::{is_help, take_value};
 pub use checksum::checksum_hex;
 pub use cli_spec::join_env_vars;
@@ -41,19 +41,165 @@ mod api_yaml {
 }
 
 #[cfg(test)]
-mod sqlite_lifecycle {
+mod driver_yaml {
+    const RAW: &str = include_str!("../../driver.yaml");
+
+    #[test]
+    fn lists_datasource_provider() {
+        assert!(RAW.contains("interface: IDatasourceProvider"));
+        for method in ["setup", "applied", "migrateUp", "migrateDown", "log"] {
+            assert!(
+                RAW.contains(&format!("  - {method}")),
+                "driver.yaml missing method {method}"
+            );
+        }
+    }
+}
+
+#[cfg(test)]
+mod core_lifecycle {
+    use std::collections::HashMap;
+    use std::sync::{Arc, Mutex};
+
+    use async_trait::async_trait;
+    use migraters_api::{BoxError, IDatasourceProvider, MigrationDriver};
+
     use crate::checksum::checksum_hex;
     use crate::infrastructure::MigrationPool;
-    use crate::migrater::{DownArg, IMigrater, Migrater, SetupArg, UpArg};
-    use crate::try_get;
+    use crate::migrater::{CreateArg, DownArg, IMigrater, Migrater, SetupArg, UpArg};
+
+    struct Store {
+        applied: Mutex<HashMap<String, Option<String>>>,
+        next_id: Mutex<i64>,
+    }
+
+    impl Store {
+        fn new() -> Arc<Self> {
+            Arc::new(Self {
+                applied: Mutex::new(HashMap::new()),
+                next_id: Mutex::new(1),
+            })
+        }
+    }
+
+    fn store_for(connection: &str) -> Arc<Store> {
+        use std::sync::OnceLock;
+        static STORES: OnceLock<Mutex<HashMap<String, Arc<Store>>>> = OnceLock::new();
+        let map = STORES.get_or_init(|| Mutex::new(HashMap::new()));
+        let mut locked = map.lock().unwrap();
+        locked
+            .entry(connection.to_string())
+            .or_insert_with(Store::new)
+            .clone()
+    }
+
+    struct CoreSession {
+        store: Arc<Store>,
+    }
+
+    #[async_trait]
+    impl MigrationDriver for CoreSession {
+        async fn setup(&self) -> Result<(), BoxError> {
+            Ok(())
+        }
+
+        async fn applied(&self) -> Result<HashMap<String, Option<String>>, BoxError> {
+            Ok(self.store.applied.lock().unwrap().clone())
+        }
+
+        async fn migrate_up(&self, name: &str, body: &str, checksum: &str) -> Result<(), BoxError> {
+            if body.contains("NOT VALID") {
+                return Err("not valid sql".into());
+            }
+            self.store
+                .applied
+                .lock()
+                .unwrap()
+                .insert(name.to_string(), Some(checksum.to_string()));
+            Ok(())
+        }
+
+        async fn migrate_down(&self, name: &str, _body: &str) -> Result<(), BoxError> {
+            self.store.applied.lock().unwrap().remove(name);
+            Ok(())
+        }
+
+        async fn log_started(&self, _name: &str, _direction: &str) -> Result<i64, BoxError> {
+            let mut next = self.store.next_id.lock().unwrap();
+            let id = *next;
+            *next += 1;
+            Ok(id)
+        }
+
+        async fn log_finished(
+            &self,
+            _id: i64,
+            _status: &str,
+            _duration_ms: i64,
+            _error: Option<&str>,
+        ) -> Result<(), BoxError> {
+            Ok(())
+        }
+
+        async fn close(&self) -> Result<(), BoxError> {
+            Ok(())
+        }
+    }
+
+    struct CoreDialect;
+
+    impl IDatasourceProvider for CoreDialect {
+        fn name(&self) -> &'static str {
+            "core"
+        }
+        fn connection_env_vars(&self) -> &'static [&'static str] {
+            &["CORE_URL"]
+        }
+        fn migrates_ddl(&self) -> &'static str {
+            "CREATE TABLE migrates (name TEXT)"
+        }
+        fn migrate_logs_ddl(&self) -> &'static str {
+            "CREATE TABLE migrate_logs (id INTEGER)"
+        }
+        fn use_transaction(&self) -> bool {
+            true
+        }
+        fn insert_applied_sql(&self) -> &'static str {
+            r#"INSERT INTO "migrates" ("name", "checksum") VALUES (?, ?)"#
+        }
+        fn delete_applied_sql(&self) -> &'static str {
+            r#"DELETE FROM "migrates" WHERE "name" = ?"#
+        }
+        fn normalize_connection(&self, connection: &str) -> String {
+            connection.to_string()
+        }
+        fn prerequisite_error(&self, _connection: &str) -> Option<String> {
+            None
+        }
+        fn prepare_setup(&self, _connection: &str) -> std::io::Result<()> {
+            Ok(())
+        }
+        fn connect<'a>(
+            &'a self,
+            connection: &'a str,
+        ) -> std::pin::Pin<
+            Box<
+                dyn std::future::Future<Output = Result<Box<dyn MigrationDriver>, BoxError>>
+                    + Send
+                    + 'a,
+            >,
+        > {
+            let store = store_for(connection);
+            Box::pin(async move { Ok(Box::new(CoreSession { store }) as Box<dyn MigrationDriver>) })
+        }
+    }
+
+    static CORE: CoreDialect = CoreDialect;
 
     #[tokio::test]
     async fn setup_apply_applied_rollback() {
-        let Some(dialect) = try_get("sqlite") else {
-            return;
-        };
         let dir = std::env::temp_dir().join(format!(
-            "migraters-api-{}-{}",
+            "migraters-core-{}-{}",
             std::process::id(),
             std::time::SystemTime::now()
                 .duration_since(std::time::UNIX_EPOCH)
@@ -61,10 +207,9 @@ mod sqlite_lifecycle {
                 .as_nanos()
         ));
         std::fs::create_dir_all(&dir).unwrap();
-        let db = dir.join("app.sqlite");
-        let connection = db.to_str().unwrap();
+        let connection = dir.to_str().unwrap();
         let migrations_path = dir.join("migrations");
-        let migrater = Migrater::new(dialect);
+        let migrater = Migrater::new(&CORE);
         migrater
             .setup(SetupArg {
                 connection,
@@ -72,6 +217,13 @@ mod sqlite_lifecycle {
             })
             .await
             .unwrap();
+        let created = migrater
+            .create(CreateArg {
+                name: "init",
+                migrations_path: migrations_path.to_str().unwrap(),
+            })
+            .unwrap();
+        assert_eq!(created.up_name, "0001_init_up.sql");
         let sql = "CREATE TABLE t (id INTEGER);\n";
         std::fs::write(migrations_path.join("0001_init_up.sql"), sql).unwrap();
         std::fs::write(
@@ -88,15 +240,24 @@ mod sqlite_lifecycle {
             .await
             .unwrap();
         assert_eq!(names, vec!["0001_init".to_string()]);
-        let pool = MigrationPool::connect(dialect, connection).await.unwrap();
+        let pool = MigrationPool::connect(&CORE, connection).await.unwrap();
         let applied = pool
-            .fetch_applied(&dialect.select_applied_checksum_sql())
+            .fetch_applied(&CORE.select_applied_checksum_sql())
             .await
             .unwrap();
         assert_eq!(
             applied.get("0001_init").cloned().flatten().as_deref(),
             Some(checksum_hex(sql).as_str())
         );
+        let again = migrater
+            .up(UpArg {
+                connection,
+                migrations_path: migrations_path.to_str().unwrap(),
+                one: false,
+            })
+            .await
+            .unwrap();
+        assert!(again.is_empty());
         let rolled = migrater
             .down(DownArg {
                 connection,
@@ -106,10 +267,45 @@ mod sqlite_lifecycle {
             .unwrap();
         assert_eq!(rolled.as_deref(), Some("0001_init"));
         let applied = pool
-            .fetch_applied(&dialect.select_applied_checksum_sql())
+            .fetch_applied(&CORE.select_applied_checksum_sql())
             .await
             .unwrap();
         assert!(!applied.contains_key("0001_init"));
         let _ = std::fs::remove_dir_all(dir);
     }
+
+    #[tokio::test]
+    async fn up_rethrows_invalid_sql() {
+        let dir = std::env::temp_dir().join(format!(
+            "migraters-core-fail-{}-{}",
+            std::process::id(),
+            std::time::SystemTime::now()
+                .duration_since(std::time::UNIX_EPOCH)
+                .unwrap()
+                .as_nanos()
+        ));
+        std::fs::create_dir_all(&dir).unwrap();
+        let connection = format!("{}-fail", dir.display());
+        let migrations_path = dir.join("migrations");
+        let migrater = Migrater::new(&CORE);
+        migrater
+            .setup(SetupArg {
+                connection: &connection,
+                migrations_path: migrations_path.to_str().unwrap(),
+            })
+            .await
+            .unwrap();
+        std::fs::write(migrations_path.join("0001_init_up.sql"), "NOT VALID SQL;\n").unwrap();
+        std::fs::write(migrations_path.join("0001_init_down.sql"), "SELECT 1;\n").unwrap();
+        let err = migrater
+            .up(UpArg {
+                connection: &connection,
+                migrations_path: migrations_path.to_str().unwrap(),
+                one: false,
+            })
+            .await
+            .unwrap_err();
+        assert!(err.to_string().contains("not valid sql"));
+        let _ = std::fs::remove_dir_all(dir);
+    }
 }