@deterministic-code/migraters 0.0.1 → 0.0.3

package/rust/dialects/sqlite/src/lib.rs

@@ -0,0 +1,286 @@
+use std::collections::HashMap;
+use std::future::Future;
+use std::pin::Pin;
+
+use async_trait::async_trait;
+use migraters_api::{catalog_name, BoxError, DialectPlugin, MigrationSession, SqlDialect};
+use sqlx::sqlite::SqlitePool;
+use sqlx::Row;
+
+pub struct SqliteDialect;
+
+pub static SQLITE: SqliteDialect = SqliteDialect;
+
+inventory::submit! {
+    DialectPlugin { dialect: &SQLITE }
+}
+
+const SQLITE_PREREQ: &str =
+    include_str!("../../../../shared/templates/messages/errors/sqlite-prerequisite.txt");
+
+impl SqlDialect for SqliteDialect {
+    fn name(&self) -> &'static str {
+        "sqlite"
+    }
+    fn connection_env_vars(&self) -> &'static [&'static str] {
+        &["SQLITE_PATH", "DB_PATH"]
+    }
+    fn migrates_ddl(&self) -> &'static str {
+        include_str!("../../../../shared/templates/sql/sqlite/migrates.sql")
+    }
+    fn migrate_logs_ddl(&self) -> &'static str {
+        include_str!("../../../../shared/templates/sql/sqlite/migrate_logs.sql")
+    }
+    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 {
+        if connection.starts_with("sqlite:") {
+            connection.to_string()
+        } else {
+            format!("sqlite://{}?mode=rwc", connection)
+        }
+    }
+    fn prerequisite_error(&self, connection: &str) -> Option<String> {
+        let path = 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(parent) = std::path::Path::new(&path).parent() {
+                if !parent.as_os_str().is_empty() {
+                    std::fs::create_dir_all(parent)?;
+                }
+            }
+        }
+        Ok(())
+    }
+    fn connect<'a>(
+        &'a self,
+        connection: &'a str,
+    ) -> Pin<Box<dyn Future<Output = Result<Box<dyn MigrationSession>, 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>)
+        })
+    }
+}
+
+struct SqliteSession {
+    pool: SqlitePool,
+}
+
+#[async_trait]
+impl MigrationSession for SqliteSession {
+    async fn execute(&self, sql: &str) -> Result<(), BoxError> {
+        sqlx::query(sql).execute(&self.pool).await?;
+        Ok(())
+    }
+
+    async fn fetch_applied(&self, sql: &str) -> Result<HashMap<String, Option<String>>, BoxError> {
+        let mut out = HashMap::new();
+        for row in sqlx::query(sql).fetch_all(&self.pool).await? {
+            let name: String = row.get(0);
+            let checksum: Option<String> = row.try_get(1).ok().flatten();
+            out.insert(catalog_name(&name).to_string(), checksum);
+        }
+        Ok(out)
+    }
+
+    async fn apply_in_transaction(
+        &self,
+        stmts: &[String],
+        catalog_sql: &str,
+        p1: &str,
+        p2: Option<&str>,
+    ) -> Result<(), BoxError> {
+        use sqlx::Executor;
+        let mut tx = self.pool.begin().await?;
+        for stmt in stmts {
+            tx.execute(stmt.as_str()).await?;
+        }
+        catalog_exec_tx(&mut tx, catalog_sql, p1, p2).await?;
+        tx.commit().await?;
+        Ok(())
+    }
+
+    async fn catalog_write(
+        &self,
+        catalog_sql: &str,
+        p1: &str,
+        p2: Option<&str>,
+    ) -> Result<(), BoxError> {
+        catalog_exec_pool(&self.pool, catalog_sql, p1, p2).await
+    }
+
+    async fn fetch_id(&self, sql: &str, p1: &str, p2: &str) -> Result<i64, BoxError> {
+        Ok(sqlx::query(sql)
+            .bind(p1)
+            .bind(p2)
+            .fetch_one(&self.pool)
+            .await?
+            .get::<i64, _>(0))
+    }
+
+    async fn update_log_exec(
+        &self,
+        sql: &str,
+        status: &str,
+        duration_ms: i64,
+        error_message: Option<&str>,
+        id: i64,
+    ) -> Result<(), BoxError> {
+        sqlx::query(sql)
+            .bind(status)
+            .bind(duration_ms)
+            .bind(error_message)
+            .bind(id)
+            .execute(&self.pool)
+            .await?;
+        Ok(())
+    }
+}
+
+async fn catalog_exec_tx(
+    tx: &mut sqlx::Transaction<'_, sqlx::Sqlite>,
+    sql: &str,
+    p1: &str,
+    p2: Option<&str>,
+) -> Result<(), BoxError> {
+    if let Some(p2) = p2 {
+        sqlx::query(sql)
+            .bind(p1)
+            .bind(p2)
+            .execute(&mut **tx)
+            .await?;
+    } else {
+        sqlx::query(sql).bind(p1).execute(&mut **tx).await?;
+    }
+    Ok(())
+}
+
+async fn catalog_exec_pool(
+    pool: &SqlitePool,
+    sql: &str,
+    p1: &str,
+    p2: Option<&str>,
+) -> Result<(), BoxError> {
+    if let Some(p2) = p2 {
+        sqlx::query(sql).bind(p1).bind(p2).execute(pool).await?;
+    } else {
+        sqlx::query(sql).bind(p1).execute(pool).await?;
+    }
+    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};
+
+    #[test]
+    fn surface_and_path_parsing() {
+        let d = SqliteDialect;
+        assert_dialect_surface(&d);
+        assert_eq!(d.name(), "sqlite");
+        assert_eq!(d.connection_env_vars(), &["SQLITE_PATH", "DB_PATH"]);
+        assert!(d.use_transaction());
+        assert_eq!(d.quote_ident("t"), "\"t\"");
+        assert_eq!(d.now_expr(), "CURRENT_TIMESTAMP");
+        assert_eq!(d.limit_clause(3), "LIMIT 3");
+        assert!(d.insert_applied_sql().contains('?'));
+        assert!(d.delete_applied_sql().contains('?'));
+
+        assert_eq!(
+            d.normalize_connection("sqlite://./app.sqlite"),
+            "sqlite://./app.sqlite"
+        );
+        assert_eq!(
+            d.normalize_connection("./app.sqlite"),
+            "sqlite://./app.sqlite?mode=rwc"
+        );
+
+        assert!(d.prerequisite_error(":memory:").is_none());
+        assert!(d.prerequisite_error("  :memory:  ").is_none());
+        assert!(d.prerequisite_error("").is_none());
+        assert!(d.prerequisite_error("sqlite://").is_none());
+        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://").is_none());
+        assert!(d.prerequisite_error("FILE:").is_none());
+        d.prepare_setup(":memory:").unwrap();
+        d.prepare_setup("app.sqlite").unwrap();
+        d.prepare_setup("/").unwrap();
+
+        let dir = std::env::temp_dir().join(format!(
+            "migraters-sqlite-paths-{}",
+            std::time::SystemTime::now()
+                .duration_since(std::time::UNIX_EPOCH)
+                .unwrap()
+                .as_nanos()
+        ));
+        std::fs::create_dir_all(&dir).unwrap();
+        let existing = dir.join("exists.sqlite");
+        std::fs::write(&existing, []).unwrap();
+        assert!(d.prerequisite_error(existing.to_str().unwrap()).is_none());
+        assert!(d
+            .prerequisite_error(&format!("Data Source={}", existing.display()))
+            .is_none());
+
+        let missing = dir.join("nested").join("missing.sqlite");
+        let err = d.prerequisite_error(missing.to_str().unwrap()).unwrap();
+        assert!(err.contains(missing.to_str().unwrap()));
+        d.prepare_setup(missing.to_str().unwrap()).unwrap();
+        assert!(missing.parent().unwrap().is_dir());
+
+        let blocker = dir.join("not-a-dir");
+        std::fs::write(&blocker, []).unwrap();
+        let blocked = blocker.join("db.sqlite");
+        assert!(d.prepare_setup(blocked.to_str().unwrap()).is_err());
+
+        assert!(d
+            .prerequisite_error(&format!("sqlite://{}", missing.display()))
+            .is_some());
+        assert!(d
+            .prerequisite_error(&format!("sqlite:{}", missing.display()))
+            .is_some());
+        assert!(d
+            .prerequisite_error(&format!("file:{}", missing.display()))
+            .is_some());
+        assert!(d.prerequisite_error("other=value.sqlite").is_some());
+        let _ = std::fs::remove_dir_all(dir);
+    }
+}

package/rust/dialects/sqlserver/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "migraters-sqlserver"
+version = "0.0.1"
+edition = "2021"
+
+[dependencies]
+async-trait = "0.1"
+inventory = "0.3"
+migraters-api = { path = "../../api" }
+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/sqlserver/src/lib.rs

@@ -0,0 +1,235 @@
+use std::collections::HashMap;
+use std::future::Future;
+use std::pin::Pin;
+
+use async_trait::async_trait;
+use migraters_api::{catalog_name, BoxError, DialectPlugin, MigrationSession, SqlDialect};
+use tiberius::{Client, Config};
+use tokio::net::TcpStream;
+use tokio::sync::Mutex;
+use tokio_util::compat::{Compat, TokioAsyncWriteCompatExt};
+
+type MssqlClient = Client<Compat<TcpStream>>;
+
+pub struct SqlServerDialect;
+
+pub static SQLSERVER: SqlServerDialect = SqlServerDialect;
+
+inventory::submit! {
+    DialectPlugin { dialect: &SQLSERVER }
+}
+
+impl SqlDialect for SqlServerDialect {
+    fn name(&self) -> &'static str {
+        "sqlserver"
+    }
+    fn connection_env_vars(&self) -> &'static [&'static str] {
+        &["MSSQL_URL", "DATABASE_URL"]
+    }
+    fn migrates_ddl(&self) -> &'static str {
+        include_str!("../../../../shared/templates/sql/sqlserver/migrates.sql")
+    }
+    fn migrate_logs_ddl(&self) -> &'static str {
+        include_str!("../../../../shared/templates/sql/sqlserver/migrate_logs.sql")
+    }
+    fn use_transaction(&self) -> bool {
+        true
+    }
+    fn insert_applied_sql(&self) -> &'static str {
+        r#"INSERT INTO [migrates] ([name], [checksum]) VALUES (@P1, @P2)"#
+    }
+    fn delete_applied_sql(&self) -> &'static str {
+        r#"DELETE FROM [migrates] WHERE [name] = @P1"#
+    }
+    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 quote_ident(&self, ident: &str) -> String {
+        format!("[{ident}]")
+    }
+    fn now_expr(&self) -> &'static str {
+        "SYSUTCDATETIME()"
+    }
+    fn limit_clause(&self, n: usize) -> String {
+        format!("OFFSET 0 ROWS FETCH NEXT {n} ROWS ONLY")
+    }
+    fn connect<'a>(
+        &'a self,
+        connection: &'a str,
+    ) -> Pin<Box<dyn Future<Output = Result<Box<dyn MigrationSession>, BoxError>> + Send + 'a>> {
+        Box::pin(async move {
+            let url = self.normalize_connection(connection);
+            let config = Config::from_ado_string(&url)
+                .or_else(|_| Config::from_jdbc_string(&url))
+                .map_err(|e| -> BoxError { e.into() })?;
+            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>)
+        })
+    }
+    fn create_database<'a>(
+        &'a self,
+        connection: &'a str,
+    ) -> Pin<Box<dyn Future<Output = Result<(), BoxError>> + Send + 'a>> {
+        Box::pin(async move { create_database(connection).await })
+    }
+}
+
+struct SqlServerSession {
+    client: Mutex<MssqlClient>,
+}
+
+#[async_trait]
+impl MigrationSession for SqlServerSession {
+    async fn execute(&self, sql: &str) -> Result<(), BoxError> {
+        let mut c = self.client.lock().await;
+        c.execute(sql, &[]).await?;
+        Ok(())
+    }
+
+    async fn fetch_applied(&self, sql: &str) -> Result<HashMap<String, Option<String>>, BoxError> {
+        let mut out = HashMap::new();
+        let mut c = self.client.lock().await;
+        let stream = c.query(sql, &[]).await?;
+        let rows = stream.into_first_result().await?;
+        for row in rows {
+            let name: &str = row.get(0).ok_or("missing migrates.name")?;
+            let checksum: Option<&str> = row.get(1);
+            out.insert(catalog_name(name).to_string(), checksum.map(str::to_string));
+        }
+        Ok(out)
+    }
+
+    async fn apply_in_transaction(
+        &self,
+        stmts: &[String],
+        catalog_sql: &str,
+        p1: &str,
+        p2: Option<&str>,
+    ) -> Result<(), BoxError> {
+        let mut c = self.client.lock().await;
+        c.simple_query("BEGIN TRAN").await?;
+        let result = async {
+            for stmt in stmts {
+                c.execute(stmt.as_str(), &[]).await?;
+            }
+            mssql_catalog(&mut c, catalog_sql, p1, p2).await
+        }
+        .await;
+        match result {
+            Ok(()) => {
+                c.simple_query("COMMIT").await?;
+                Ok(())
+            }
+            Err(e) => {
+                let _ = c.simple_query("ROLLBACK").await;
+                Err(e)
+            }
+        }
+    }
+
+    async fn catalog_write(
+        &self,
+        catalog_sql: &str,
+        p1: &str,
+        p2: Option<&str>,
+    ) -> Result<(), BoxError> {
+        let mut c = self.client.lock().await;
+        mssql_catalog(&mut c, catalog_sql, p1, p2).await
+    }
+
+    async fn fetch_id(&self, sql: &str, p1: &str, p2: &str) -> Result<i64, BoxError> {
+        let mut c = self.client.lock().await;
+        let stream = c.query(sql, &[&p1 as &dyn tiberius::ToSql, &p2]).await?;
+        let row = stream.into_row().await?.ok_or("missing migrate_logs id")?;
+        Ok(row.get::<i64, usize>(0).ok_or("missing migrate_logs id")?)
+    }
+
+    async fn update_log_exec(
+        &self,
+        sql: &str,
+        status: &str,
+        duration_ms: i64,
+        error_message: Option<&str>,
+        id: i64,
+    ) -> Result<(), BoxError> {
+        let mut c = self.client.lock().await;
+        let err = error_message.unwrap_or("");
+        c.execute(sql, &[&status, &duration_ms, &err, &id]).await?;
+        Ok(())
+    }
+}
+
+async fn mssql_catalog(
+    client: &mut MssqlClient,
+    sql: &str,
+    p1: &str,
+    p2: Option<&str>,
+) -> Result<(), BoxError> {
+    if let Some(p2) = p2 {
+        client.execute(sql, &[&p1, &p2]).await?;
+    } else {
+        client.execute(sql, &[&p1]).await?;
+    }
+    Ok(())
+}
+
+async fn create_database(connection: &str) -> Result<(), BoxError> {
+    let Some(name) = connection.split(';').find_map(|part| {
+        let (k, v) = part.split_once('=')?;
+        k.eq_ignore_ascii_case("Database").then_some(v)
+    }) else {
+        return Ok(());
+    };
+    if name.eq_ignore_ascii_case("master") {
+        return Ok(());
+    }
+    let admin = connection.replace(&format!("Database={name}"), "Database=master");
+    let config = Config::from_ado_string(&admin)
+        .or_else(|_| Config::from_jdbc_string(&admin))?;
+    let tcp = TcpStream::connect(config.get_addr()).await?;
+    tcp.set_nodelay(true)?;
+    let mut client = Client::connect(config, tcp.compat_write()).await?;
+    let sql = format!(
+        "IF DB_ID(N'{}') IS NULL CREATE DATABASE [{}]",
+        name.replace('\'', "''"),
+        name
+    );
+    client.simple_query(sql).await?;
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::SqlServerDialect;
+    use migraters_api::{assert_dialect_surface, SqlDialect};
+
+    #[test]
+    fn surface() {
+        let d = SqlServerDialect;
+        assert_dialect_surface(&d);
+        assert_eq!(d.name(), "sqlserver");
+        assert_eq!(d.connection_env_vars(), &["MSSQL_URL", "DATABASE_URL"]);
+        assert!(d.use_transaction());
+        assert_eq!(
+            d.normalize_connection("Server=localhost"),
+            "Server=localhost"
+        );
+        assert!(d.prerequisite_error("Server=localhost").is_none());
+        d.prepare_setup("Server=localhost").unwrap();
+        assert!(d.insert_applied_sql().contains("@P1"));
+        assert!(d.delete_applied_sql().contains("@P1"));
+        assert_eq!(d.quote_ident("t"), "[t]");
+        assert_eq!(d.now_expr(), "SYSUTCDATETIME()");
+        assert_eq!(d.limit_clause(4), "OFFSET 0 ROWS FETCH NEXT 4 ROWS ONLY");
+    }
+}

package/rust/rustfmt.toml

@@ -0,0 +1,2 @@
+edition = "2021"
+max_width = 100

package/rust/src/abstractions/factory.rs

@@ -0,0 +1,17 @@
+use crate::provider::normalize_provider;
+use migraters_api::registered_dialects;
+
+use super::SqlDialect;
+
+pub fn try_get(name: &str) -> Option<&'static dyn SqlDialect> {
+    let key = normalize_provider(name)?;
+    registered_dialects()
+        .into_iter()
+        .find(|dialect| dialect.name() == key)
+}
+
+pub fn all() -> Vec<&'static dyn SqlDialect> {
+    let mut dialects = registered_dialects();
+    dialects.sort_by_key(|dialect| dialect.name());
+    dialects
+}

package/rust/src/abstractions/mod.rs

@@ -0,0 +1,5 @@
+mod factory;
+mod sql_dialect;
+
+pub use factory::{all, try_get};
+pub use sql_dialect::SqlDialect;

package/rust/src/abstractions/sql_dialect.rs

@@ -0,0 +1 @@
+pub use migraters_api::SqlDialect;

package/rust/src/argv.rs

@@ -0,0 +1,15 @@
+pub fn take_value(
+    arg: &str,
+    iter: &mut impl Iterator<Item = String>,
+    flag: &str,
+) -> Option<String> {
+    if arg == flag {
+        return iter.next();
+    }
+    let prefix = format!("{flag}=");
+    arg.strip_prefix(&prefix).map(str::to_string)
+}
+
+pub fn is_help(arg: &str) -> bool {
+    arg == "-h" || arg == "--help"
+}

package/rust/src/attached_dialects.rs

@@ -0,0 +1,2 @@
+// migrate-init attaches selected dialect crates here.
+#![allow(unused_imports)]

package/rust/src/bin/migrate_create.rs

@@ -0,0 +1,97 @@
+// Scaffolds a new <NNNN>_<name>_{up,down}.sql pair in the migrations directory. Numbering is max(1-4-digit prefix in dir)+1; legacy timestamp prefixes are ignored.
+
+use std::env;
+use std::process;
+
+use deterministic_migraters::{
+    fill_help_template, is_help, is_migration_name, message, take_value, try_get, CreateArg,
+    IMigrater, Migrater, SqlDialect,
+};
+
+const HELP_TEMPLATE: &str = include_str!("../../../shared/templates/help/create.txt");
+
+fn help_text() -> String {
+    fill_help_template(HELP_TEMPLATE, "migrate-create")
+}
+
+struct Args {
+    dialect: &'static dyn SqlDialect,
+    name: String,
+    migrations_path: String,
+}
+
+fn parse_args() -> Result<Args, String> {
+    let mut provider: Option<String> = None;
+    let mut name: Option<String> = None;
+    let mut migrations_path: Option<String> = None;
+    let mut iter = env::args().skip(1);
+    while let Some(a) = iter.next() {
+        if is_help(&a) {
+            eprint!("{}", help_text());
+            process::exit(0);
+        }
+        if let Some(v) = take_value(&a, &mut iter, "--provider") {
+            provider = Some(v);
+        } else if let Some(v) = take_value(&a, &mut iter, "--name") {
+            name = Some(v);
+        } else if let Some(v) = take_value(&a, &mut iter, "--migrations-path")
+            .or_else(|| take_value(&a, &mut iter, "--migrate-path"))
+        {
+            migrations_path = Some(v);
+        } else {
+            return Err(message("errors/unknown-arg", &[("arg", &a)]));
+        }
+    }
+    let Some(provider) = provider else {
+        return Err(message("errors/missing-provider", &[]));
+    };
+    let Some(dialect) = try_get(&provider) else {
+        return Err(message(
+            "errors/unsupported-provider",
+            &[("provider", &provider)],
+        ));
+    };
+    let Some(name) = name else {
+        return Err(message("errors/missing-name", &[]));
+    };
+    if !is_migration_name(&name) {
+        return Err(message("errors/invalid-name", &[("name", &name)]));
+    }
+    let migrations_path =
+        migrations_path.unwrap_or_else(|| format!("./sql/{}/migrations", dialect.name()));
+    Ok(Args {
+        dialect,
+        name,
+        migrations_path,
+    })
+}
+
+fn main() {
+    let args = match parse_args() {
+        Ok(a) => a,
+        Err(msg) => {
+            eprintln!("{}", msg);
+            process::exit(2);
+        }
+    };
+    if let Err(e) = run(&args) {
+        eprintln!("{}", e);
+        process::exit(1);
+    }
+}
+
+fn run(args: &Args) -> Result<(), Box<dyn std::error::Error>> {
+    let created = Migrater::new(args.dialect).create(CreateArg {
+        name: &args.name,
+        migrations_path: &args.migrations_path,
+    })?;
+    print!(
+        "{}",
+        message("status/created", &[("file", &created.up_name)])
+    );
+    print!(
+        "{}",
+        message("status/created", &[("file", &created.down_name)])
+    );
+    Ok(())
+}