@deterministic-code/migraters 0.0.2 → 0.0.4

package/rust/src/cli_spec.rs

@@ -0,0 +1,249 @@
+use std::collections::HashMap;
+use std::sync::OnceLock;
+
+const RAW: &str = include_str!("../../cli.yaml");
+
+#[derive(Clone)]
+struct CliArg {
+    flag: String,
+    placeholder: Option<String>,
+    required: bool,
+}
+
+#[derive(Clone)]
+struct CliCommand {
+    verb: String,
+    args: Vec<CliArg>,
+}
+
+struct CliSpec {
+    command: String,
+    providers: Vec<String>,
+    languages: Vec<String>,
+    provider_aliases: HashMap<String, String>,
+    env_var_list_separator: String,
+    commands: Vec<CliCommand>,
+}
+
+fn spec() -> &'static CliSpec {
+    static SPEC: OnceLock<CliSpec> = OnceLock::new();
+    SPEC.get_or_init(parse_cli_yaml)
+}
+
+fn parse_arg_flow(line: &str) -> CliArg {
+    let start = line.find('{').expect("cli.yaml arg mapping");
+    let end = line.rfind('}').expect("cli.yaml arg mapping");
+    let mut flag = String::new();
+    let mut placeholder = None;
+    let mut required = false;
+    for part in line[start + 1..end].split(',') {
+        let Some((key, value)) = part.split_once(':') else {
+            continue;
+        };
+        let key = key.trim();
+        let value = value.trim();
+        match key {
+            "flag" => flag = value.to_string(),
+            "placeholder" => placeholder = Some(value.to_string()),
+            "required" => required = value == "true",
+            _ => {}
+        }
+    }
+    CliArg {
+        flag,
+        placeholder,
+        required,
+    }
+}
+
+fn unquote(value: &str) -> String {
+    let v = value.trim();
+    if let Some(inner) = v.strip_prefix('"').and_then(|s| s.strip_suffix('"')) {
+        inner.to_string()
+    } else {
+        v.to_string()
+    }
+}
+
+fn parse_cli_yaml() -> CliSpec {
+    let mut command = String::from("migrate-{verb}");
+    let mut providers = Vec::new();
+    let mut languages = Vec::new();
+    let mut provider_aliases = HashMap::new();
+    let mut env_var_list_separator = String::from(" / ");
+    let mut commands = Vec::new();
+    let mut in_providers = false;
+    let mut in_languages = false;
+    let mut in_aliases = false;
+    let mut in_commands = false;
+    let mut current: Option<CliCommand> = None;
+    let mut in_args = false;
+
+    for raw in RAW.lines() {
+        let line = raw.trim_end();
+        if line.is_empty() || line.starts_with('#') {
+            continue;
+        }
+        if !line.starts_with(' ') && !line.starts_with('-') {
+            in_providers = false;
+            in_languages = false;
+            in_aliases = false;
+            if !line.starts_with("commands:") {
+                in_commands = false;
+                in_args = false;
+                if let Some(cmd) = current.take() {
+                    commands.push(cmd);
+                }
+            }
+        }
+        if line.starts_with("command:") {
+            command = line.split_once(':').unwrap().1.trim().to_string();
+            continue;
+        }
+        if line.starts_with("env_var_list_separator:") {
+            env_var_list_separator = unquote(line.split_once(':').unwrap().1);
+            continue;
+        }
+        if line.starts_with("providers:") {
+            in_providers = true;
+            continue;
+        }
+        if line.starts_with("languages:") {
+            in_languages = true;
+            continue;
+        }
+        if line.starts_with("provider_aliases:") {
+            in_aliases = true;
+            continue;
+        }
+        if line.starts_with("commands:") {
+            in_commands = true;
+            continue;
+        }
+        if in_providers {
+            if let Some(name) = line.trim().strip_prefix("- ") {
+                providers.push(name.trim().to_string());
+            }
+            continue;
+        }
+        if in_languages {
+            if let Some(name) = line.trim().strip_prefix("- ") {
+                languages.push(name.trim().to_string());
+            }
+            continue;
+        }
+        if in_aliases {
+            let trimmed = line.trim();
+            if let Some((alias, canonical)) = trimmed.split_once(':') {
+                let alias = crate::provider::strip_key(alias.trim());
+                let canonical = canonical.trim().to_string();
+                if !alias.is_empty() && !canonical.is_empty() {
+                    provider_aliases.insert(alias, canonical);
+                }
+            }
+            continue;
+        }
+        if !in_commands {
+            continue;
+        }
+        let trimmed = line.trim();
+        if let Some(verb) = trimmed.strip_prefix("- verb:") {
+            if let Some(cmd) = current.take() {
+                commands.push(cmd);
+            }
+            current = Some(CliCommand {
+                verb: verb.trim().to_string(),
+                args: Vec::new(),
+            });
+            in_args = false;
+            continue;
+        }
+        if trimmed == "args:" {
+            in_args = true;
+            continue;
+        }
+        if in_args && trimmed.starts_with("- {") {
+            if let Some(cmd) = current.as_mut() {
+                cmd.args.push(parse_arg_flow(trimmed));
+            }
+        } else if in_args {
+            if let Some(flag) = trimmed.strip_prefix("- flag:") {
+                if let Some(cmd) = current.as_mut() {
+                    cmd.args.push(CliArg {
+                        flag: flag.trim().to_string(),
+                        placeholder: None,
+                        required: false,
+                    });
+                }
+            } else if let Some(cmd) = current.as_mut() {
+                if let Some(last) = cmd.args.last_mut() {
+                    if let Some(placeholder) = trimmed.strip_prefix("placeholder:") {
+                        last.placeholder = Some(placeholder.trim().to_string());
+                    } else if let Some(required) = trimmed.strip_prefix("required:") {
+                        last.required = required.trim() == "true";
+                    }
+                }
+            }
+        }
+    }
+    if let Some(cmd) = current.take() {
+        commands.push(cmd);
+    }
+    CliSpec {
+        command,
+        providers,
+        languages,
+        provider_aliases,
+        env_var_list_separator,
+        commands,
+    }
+}
+
+fn arg_usage(arg: &CliArg, providers: &str, languages: &str) -> String {
+    let body = match &arg.placeholder {
+        Some(token) if token == "providers" => format!("{} <{}>", arg.flag, providers),
+        Some(token) if token == "languages" => format!("{} <{}>", arg.flag, languages),
+        Some(token) => format!("{} <{}>", arg.flag, token),
+        None => arg.flag.clone(),
+    };
+    if arg.required {
+        body
+    } else {
+        format!("[{body}]")
+    }
+}
+
+pub fn usage_line(verb: &str) -> String {
+    let spec = spec();
+    let providers = spec.providers.join("|");
+    let languages = spec.languages.join("|");
+    let command_name = spec.command.replace("{verb}", verb);
+    let command = spec
+        .commands
+        .iter()
+        .find(|c| c.verb == verb)
+        .unwrap_or_else(|| panic!("cli.yaml: missing command {verb}"));
+    let args = command
+        .args
+        .iter()
+        .map(|a| arg_usage(a, &providers, &languages))
+        .collect::<Vec<_>>()
+        .join(" ");
+    format!("Usage: {command_name} {args}")
+}
+
+pub fn providers() -> &'static [String] {
+    &spec().providers
+}
+
+pub fn provider_aliases() -> &'static HashMap<String, String> {
+    &spec().provider_aliases
+}
+
+pub fn env_var_list_separator() -> &'static str {
+    spec().env_var_list_separator.as_str()
+}
+
+pub fn join_env_vars(vars: &[&str]) -> String {
+    vars.join(env_var_list_separator())
+}

package/rust/src/dialects/mod.rs

@@ -0,0 +1,4 @@
+#[allow(dead_code)]
+pub(crate) fn assert_dialect_surface(d: &dyn crate::abstractions::SqlDialect) {
+    migraters_api::assert_dialect_surface(d);
+}

package/rust/src/help.rs

@@ -0,0 +1,10 @@
+use crate::cli_spec::usage_line;
+use crate::messages::fill_template;
+
+pub fn fill_help_template(template: &str, command: &str) -> String {
+    let verb = command
+        .strip_prefix("migrate-")
+        .expect("help command must be migrate-<verb>");
+    let usage = usage_line(verb);
+    fill_template(template, &[("command", command), ("usage", &usage)])
+}

package/rust/src/infrastructure/connection_resolver.rs

@@ -0,0 +1,8 @@
+use crate::abstractions::SqlDialect;
+
+pub fn connection_from_env(dialect: &dyn SqlDialect) -> Option<String> {
+    dialect
+        .connection_env_vars()
+        .iter()
+        .find_map(|name| std::env::var(name).ok().filter(|v| !v.is_empty()))
+}

package/rust/src/infrastructure/create_database.rs

@@ -0,0 +1,15 @@
+use crate::abstractions::try_get;
+
+pub async fn create_database(
+    provider: &str,
+    connection: &str,
+) -> Result<(), Box<dyn std::error::Error>> {
+    let Some(dialect) = try_get(provider) else {
+        return Ok(());
+    };
+    dialect
+        .create_database(connection)
+        .await
+        .map_err(|err| err.to_string())?;
+    Ok(())
+}

package/rust/src/infrastructure/mod.rs

@@ -0,0 +1,9 @@
+mod connection_resolver;
+mod create_database;
+mod pool;
+mod split_on_go;
+
+pub use connection_resolver::connection_from_env;
+pub use create_database::create_database;
+pub use pool::MigrationPool;
+pub use split_on_go::split_on_go;

package/rust/src/infrastructure/pool.rs

@@ -0,0 +1,79 @@
+use std::collections::HashMap;
+
+use crate::abstractions::SqlDialect;
+use migraters_api::{
+    apply_statements, insert_log_started, update_log, BoxError as ApiError, MigrationSession,
+};
+
+type BoxError = Box<dyn std::error::Error>;
+
+fn cast(err: ApiError) -> BoxError {
+    err.to_string().into()
+}
+
+pub struct MigrationPool {
+    session: Box<dyn MigrationSession>,
+}
+
+impl MigrationPool {
+    pub async fn connect(dialect: &dyn SqlDialect, connection: &str) -> Result<Self, BoxError> {
+        Ok(Self {
+            session: dialect.connect(connection).await.map_err(cast)?,
+        })
+    }
+
+    pub async fn execute(&self, sql: &str) -> Result<(), BoxError> {
+        self.session.execute(sql).await.map_err(cast)
+    }
+
+    pub async fn fetch_applied(
+        &self,
+        sql: &str,
+    ) -> Result<HashMap<String, Option<String>>, BoxError> {
+        self.session.fetch_applied(sql).await.map_err(cast)
+    }
+
+    pub async fn apply_statements(
+        &self,
+        dialect: &dyn SqlDialect,
+        sql: &str,
+        catalog_sql: &str,
+        p1: &str,
+        p2: Option<&str>,
+    ) -> Result<(), BoxError> {
+        apply_statements(&*self.session, dialect, sql, catalog_sql, p1, p2)
+            .await
+            .map_err(cast)
+    }
+
+    pub async fn insert_log_started(
+        &self,
+        dialect: &dyn SqlDialect,
+        name: &str,
+        direction: &str,
+    ) -> Result<i64, BoxError> {
+        insert_log_started(&*self.session, dialect, name, direction)
+            .await
+            .map_err(cast)
+    }
+
+    pub async fn update_log(
+        &self,
+        dialect: &dyn SqlDialect,
+        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)
+    }
+}

package/rust/src/infrastructure/split_on_go.rs

@@ -0,0 +1,48 @@
+// Whole-line GO separates batches (sqlcmd-style).
+pub fn split_on_go(sql: &str) -> Vec<String> {
+    let mut out = Vec::new();
+    let mut buf = String::new();
+    for line in sql.replace("\r\n", "\n").split('\n') {
+        if line.trim().eq_ignore_ascii_case("GO") {
+            let s = buf.trim();
+            if !s.is_empty() {
+                out.push(s.to_string());
+            }
+            buf.clear();
+            continue;
+        }
+        if !buf.is_empty() {
+            buf.push('\n');
+        }
+        buf.push_str(line);
+    }
+    let tail = buf.trim();
+    if !tail.is_empty() {
+        out.push(tail.to_string());
+    }
+    out
+}
+
+#[cfg(test)]
+mod tests {
+    use super::split_on_go;
+
+    #[test]
+    fn splits_on_whole_line_go() {
+        assert_eq!(
+            split_on_go("CREATE TABLE a (id INT);\nGO\nCREATE TABLE b (id INT)"),
+            vec![
+                "CREATE TABLE a (id INT);".to_string(),
+                "CREATE TABLE b (id INT)".to_string(),
+            ]
+        );
+    }
+
+    #[test]
+    fn keeps_semicolons_inside_one_batch() {
+        assert_eq!(
+            split_on_go("BEGIN\n  SELECT 1;\nEND;"),
+            vec!["BEGIN\n  SELECT 1;\nEND;".to_string()]
+        );
+    }
+}

package/rust/src/lib.rs

@@ -0,0 +1,115 @@
+mod attached_dialects;
+pub mod abstractions;
+pub mod argv;
+pub mod checksum;
+pub mod cli_spec;
+pub mod dialects;
+pub mod help;
+pub mod infrastructure;
+pub mod messages;
+pub mod migrater;
+pub mod migrations;
+pub mod provider;
+
+pub use abstractions::{all, try_get, SqlDialect};
+pub use argv::{is_help, take_value};
+pub use checksum::checksum_hex;
+pub use cli_spec::join_env_vars;
+pub use help::fill_help_template;
+pub use infrastructure::{connection_from_env, create_database, MigrationPool};
+pub use messages::{fill_template, message, scaffold};
+pub use migrater::{CreateArg, CreateResponse, DownArg, IMigrater, Migrater, SetupArg, UpArg};
+pub use migrations::{
+    assert_no_checksum_drift, catalog_name, discover_up_files, down_path_for, is_migration_name,
+    next_sequence,
+};
+
+#[cfg(test)]
+mod api_yaml {
+    const RAW: &str = include_str!("../../api.yaml");
+
+    #[test]
+    fn lists_imigrater() {
+        assert!(RAW.contains("interface: IMigrater"));
+        for method in ["setup", "up", "down", "create"] {
+            assert!(
+                RAW.contains(&format!("  - {method}")),
+                "api.yaml missing method {method}"
+            );
+        }
+    }
+}
+
+#[cfg(test)]
+mod sqlite_lifecycle {
+    use crate::checksum::checksum_hex;
+    use crate::infrastructure::MigrationPool;
+    use crate::migrater::{DownArg, IMigrater, Migrater, SetupArg, UpArg};
+    use crate::try_get;
+
+    #[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-{}-{}",
+            std::process::id(),
+            std::time::SystemTime::now()
+                .duration_since(std::time::UNIX_EPOCH)
+                .unwrap()
+                .as_nanos()
+        ));
+        std::fs::create_dir_all(&dir).unwrap();
+        let db = dir.join("app.sqlite");
+        let connection = db.to_str().unwrap();
+        let migrations_path = dir.join("migrations");
+        let migrater = Migrater::new(dialect);
+        migrater
+            .setup(SetupArg {
+                connection,
+                migrations_path: migrations_path.to_str().unwrap(),
+            })
+            .await
+            .unwrap();
+        let sql = "CREATE TABLE t (id INTEGER);\n";
+        std::fs::write(migrations_path.join("0001_init_up.sql"), sql).unwrap();
+        std::fs::write(
+            migrations_path.join("0001_init_down.sql"),
+            "DROP TABLE t;\n",
+        )
+        .unwrap();
+        let names = migrater
+            .up(UpArg {
+                connection,
+                migrations_path: migrations_path.to_str().unwrap(),
+                one: false,
+            })
+            .await
+            .unwrap();
+        assert_eq!(names, vec!["0001_init".to_string()]);
+        let pool = MigrationPool::connect(dialect, connection).await.unwrap();
+        let applied = pool
+            .fetch_applied(&dialect.select_applied_checksum_sql())
+            .await
+            .unwrap();
+        assert_eq!(
+            applied.get("0001_init").cloned().flatten().as_deref(),
+            Some(checksum_hex(sql).as_str())
+        );
+        let rolled = migrater
+            .down(DownArg {
+                connection,
+                migrations_path: migrations_path.to_str().unwrap(),
+            })
+            .await
+            .unwrap();
+        assert_eq!(rolled.as_deref(), Some("0001_init"));
+        let applied = pool
+            .fetch_applied(&dialect.select_applied_checksum_sql())
+            .await
+            .unwrap();
+        assert!(!applied.contains_key("0001_init"));
+        let _ = std::fs::remove_dir_all(dir);
+    }
+}

package/rust/src/messages.rs

@@ -0,0 +1,102 @@
+pub fn fill_template(template: &str, vars: &[(&str, &str)]) -> String {
+    let mut out = template.to_string();
+    for (key, value) in vars {
+        out = out.replace(&format!("{{{{{key}}}}}"), value);
+    }
+    out
+}
+
+fn raw_message(path: &str) -> &'static str {
+    match path {
+        "setup-complete" => include_str!("../../shared/templates/messages/setup-complete.txt"),
+        "status/no-pending" => {
+            include_str!("../../shared/templates/messages/status/no-pending.txt")
+        }
+        "status/no-more-pending" => {
+            include_str!("../../shared/templates/messages/status/no-more-pending.txt")
+        }
+        "status/applied" => include_str!("../../shared/templates/messages/status/applied.txt"),
+        "status/created" => include_str!("../../shared/templates/messages/status/created.txt"),
+        "status/rolled-back" => {
+            include_str!("../../shared/templates/messages/status/rolled-back.txt")
+        }
+        "status/no-rollback" => {
+            include_str!("../../shared/templates/messages/status/no-rollback.txt")
+        }
+        "down/destructive-header" => {
+            include_str!("../../shared/templates/messages/down/destructive-header.txt")
+        }
+        "down/confirm-mismatch" => {
+            include_str!("../../shared/templates/messages/down/confirm-mismatch.txt")
+        }
+        "down/confirm-tty-required" => {
+            include_str!("../../shared/templates/messages/down/confirm-tty-required.txt")
+        }
+        "down/confirm-prompt" => {
+            include_str!("../../shared/templates/messages/down/confirm-prompt.txt")
+        }
+        "down/confirm-stdin-failed" => {
+            include_str!("../../shared/templates/messages/down/confirm-stdin-failed.txt")
+        }
+        "down/confirm-token-mismatch" => {
+            include_str!("../../shared/templates/messages/down/confirm-token-mismatch.txt")
+        }
+        "errors/missing-provider" => {
+            include_str!("../../shared/templates/messages/errors/missing-provider.txt")
+        }
+        "errors/missing-provider-hint" => {
+            include_str!("../../shared/templates/messages/errors/missing-provider-hint.txt")
+        }
+        "errors/missing-connection" => {
+            include_str!("../../shared/templates/messages/errors/missing-connection.txt")
+        }
+        "errors/missing-name" => {
+            include_str!("../../shared/templates/messages/errors/missing-name.txt")
+        }
+        "errors/missing-name-hint" => {
+            include_str!("../../shared/templates/messages/errors/missing-name-hint.txt")
+        }
+        "errors/invalid-name" => {
+            include_str!("../../shared/templates/messages/errors/invalid-name.txt")
+        }
+        "errors/unknown-arg" => {
+            include_str!("../../shared/templates/messages/errors/unknown-arg.txt")
+        }
+        "errors/unsupported-provider" => {
+            include_str!("../../shared/templates/messages/errors/unsupported-provider.txt")
+        }
+        "errors/missing-value-for-flag" => {
+            include_str!("../../shared/templates/messages/errors/missing-value-for-flag.txt")
+        }
+        "errors/migrate-path-not-dir" => {
+            include_str!("../../shared/templates/messages/errors/migrate-path-not-dir.txt")
+        }
+        "errors/rollback-no-down-sibling" => {
+            include_str!("../../shared/templates/messages/errors/rollback-no-down-sibling.txt")
+        }
+        "errors/rollback-not-in-path" => {
+            include_str!("../../shared/templates/messages/errors/rollback-not-in-path.txt")
+        }
+        "checksum-drift" => include_str!("../../shared/templates/messages/checksum-drift.txt"),
+        "checksum-drift-line" => {
+            include_str!("../../shared/templates/messages/checksum-drift-line.txt")
+        }
+        "errors/sqlite-prerequisite" => {
+            include_str!("../../shared/templates/messages/errors/sqlite-prerequisite.txt")
+        }
+        _ => panic!("unknown message template: {path}"),
+    }
+}
+
+pub fn message(path: &str, vars: &[(&str, &str)]) -> String {
+    fill_template(raw_message(path), vars)
+}
+
+pub fn scaffold(name: &str, vars: &[(&str, &str)]) -> String {
+    let template = match name {
+        "up" => include_str!("../../shared/templates/scaffold/up.sql"),
+        "down" => include_str!("../../shared/templates/scaffold/down.sql"),
+        _ => panic!("unknown scaffold template: {name}"),
+    };
+    fill_template(template, vars)
+}