@deterministic-code/migraters 0.0.2 → 0.0.4

package/rust/src/bin/migrate_down.rs

@@ -0,0 +1,151 @@
+// Rolls back the most recently applied migration (one step). DESTRUCTIVE: refuses to proceed unless the operator types confirm on stdin, or passes --confirm.
+
+use std::env;
+use std::io::{self, BufRead, IsTerminal, Write};
+use std::process;
+
+use deterministic_migraters::{
+    connection_from_env, fill_help_template, is_help, join_env_vars, message, take_value, try_get,
+    DownArg, IMigrater, Migrater, SqlDialect,
+};
+
+const HELP_TEMPLATE: &str = include_str!("../../../shared/templates/help/down.txt");
+
+fn help_text() -> String {
+    fill_help_template(HELP_TEMPLATE, "migrate-down")
+}
+
+struct Args {
+    dialect: &'static dyn SqlDialect,
+    migrate_path: String,
+    connection: String,
+    confirm: bool,
+}
+
+fn parse_args() -> Result<Args, String> {
+    let mut provider: Option<String> = None;
+    let mut migrate_path: Option<String> = None;
+    let mut migrate_root: Option<String> = None;
+    let mut connection: Option<String> = None;
+    let mut confirm = false;
+    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, "--migrations-path")
+            .or_else(|| take_value(&a, &mut iter, "--migrate-path"))
+        {
+            migrate_path = Some(v);
+        } else if let Some(v) = take_value(&a, &mut iter, "--migrations-root")
+            .or_else(|| take_value(&a, &mut iter, "--migrate-root"))
+        {
+            migrate_root = Some(v);
+        } else if let Some(v) = take_value(&a, &mut iter, "--connection") {
+            connection = Some(v);
+        } else if a == "--confirm" {
+            confirm = true;
+        } 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 migrate_path = migrate_path.unwrap_or_else(|| {
+        let root = migrate_root.unwrap_or_else(|| "sql".to_string());
+        format!("{}/{}/migrations", root, dialect.name())
+    });
+    let connection = match connection.or_else(|| connection_from_env(dialect)) {
+        Some(c) => c,
+        None => {
+            return Err(message(
+                "errors/missing-connection",
+                &[("envVars", &join_env_vars(dialect.connection_env_vars()))],
+            ))
+        }
+    };
+    Ok(Args {
+        dialect,
+        migrate_path,
+        connection,
+        confirm,
+    })
+}
+
+fn confirm_or_abort(dialect: &str, confirm: bool) {
+    let stderr = io::stderr();
+    let mut err = stderr.lock();
+    let _ = write!(
+        err,
+        "{}",
+        message("down/destructive-header", &[("dialect", dialect)]),
+    );
+    if confirm {
+        return;
+    }
+    if !io::stdin().is_terminal() {
+        let _ = writeln!(err, "{}", message("down/confirm-tty-required", &[]),);
+        process::exit(2);
+    }
+    let _ = write!(err, "{}", message("down/confirm-prompt", &[]),);
+    let _ = err.flush();
+    let stdin = io::stdin();
+    let mut line = String::new();
+    match stdin.lock().read_line(&mut line) {
+        Ok(_) => {}
+        Err(_) => {
+            let _ = writeln!(err, "{}", message("down/confirm-stdin-failed", &[]),);
+            process::exit(2);
+        }
+    }
+    if line.trim() != "confirm" {
+        let _ = writeln!(err, "{}", message("down/confirm-token-mismatch", &[]),);
+        process::exit(2);
+    }
+}
+
+async fn rollback_last(args: &Args) -> Result<(), Box<dyn std::error::Error>> {
+    match Migrater::new(args.dialect)
+        .down(DownArg {
+            connection: &args.connection,
+            migrations_path: &args.migrate_path,
+        })
+        .await?
+    {
+        None => print!("{}", message("status/no-rollback", &[])),
+        Some(name) => print!("{}", message("status/rolled-back", &[("name", &name)])),
+    }
+    Ok(())
+}
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    match dotenvy::from_path(".env") {
+        Ok(()) => {}
+        Err(dotenvy::Error::Io(err)) if err.kind() == std::io::ErrorKind::NotFound => {}
+        Err(err) => return Err(format!("failed to load .env: {err}").into()),
+    }
+    let args = match parse_args() {
+        Ok(a) => a,
+        Err(msg) => {
+            eprintln!("{}", msg);
+            process::exit(2);
+        }
+    };
+    if let Some(msg) = args.dialect.prerequisite_error(&args.connection) {
+        eprintln!("{}", msg);
+        process::exit(2);
+    }
+    confirm_or_abort(args.dialect.name(), args.confirm);
+    rollback_last(&args).await
+}

package/rust/src/bin/migrate_setup.rs

@@ -0,0 +1,153 @@
+// Idempotent CREATE TABLE IF NOT EXISTS migrates+migrate_logs via IMigrater.setup.
+
+use std::env;
+use std::process;
+
+use deterministic_migraters::{
+    connection_from_env, create_database, fill_help_template, is_help, join_env_vars, message,
+    take_value, try_get, IMigrater, Migrater, SetupArg, SqlDialect, UpArg,
+};
+
+const HELP_TEMPLATE: &str = include_str!("../../../shared/templates/help/setup.txt");
+
+fn help_text() -> String {
+    fill_help_template(HELP_TEMPLATE, "migrate-setup")
+}
+
+struct Args {
+    dialect: &'static dyn SqlDialect,
+    connection: String,
+    migrations_path: String,
+    and_up: bool,
+    create_database: bool,
+}
+
+fn parse_args() -> Result<Args, String> {
+    let mut provider: Option<String> = None;
+    let mut connection: Option<String> = None;
+    let mut migrations_path: Option<String> = None;
+    let mut and_up = false;
+    let mut create_database = false;
+    let mut iter = env::args().skip(1);
+    while let Some(a) = iter.next() {
+        if is_help(&a) {
+            eprint!("{}", help_text());
+            process::exit(0);
+        }
+        if a == "--and-up" {
+            and_up = true;
+            continue;
+        }
+        if a == "--create-database" {
+            create_database = true;
+            continue;
+        }
+        if let Some(v) = take_value(&a, &mut iter, "--provider") {
+            provider = Some(v);
+        } else if let Some(v) = take_value(&a, &mut iter, "--connection") {
+            connection = 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 connection = match connection.or_else(|| connection_from_env(dialect)) {
+        Some(c) => c,
+        None => {
+            return Err(message(
+                "errors/missing-connection",
+                &[("envVars", &join_env_vars(dialect.connection_env_vars()))],
+            ))
+        }
+    };
+    let migrations_path =
+        migrations_path.unwrap_or_else(|| format!("./sql/{}/migrations", dialect.name()));
+    Ok(Args {
+        dialect,
+        connection,
+        migrations_path,
+        and_up,
+        create_database,
+    })
+}
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    match dotenvy::from_path(".env") {
+        Ok(()) => {}
+        Err(dotenvy::Error::Io(err)) if err.kind() == std::io::ErrorKind::NotFound => {}
+        Err(err) => return Err(format!("failed to load .env: {err}").into()),
+    }
+    let args = match parse_args() {
+        Ok(a) => a,
+        Err(msg) => {
+            eprintln!("{}", msg);
+            process::exit(2);
+        }
+    };
+    if args.create_database {
+        create_database(args.dialect.name(), &args.connection).await?;
+    }
+    let migrater = Migrater::new(args.dialect);
+    migrater
+        .setup(SetupArg {
+            connection: &args.connection,
+            migrations_path: &args.migrations_path,
+        })
+        .await?;
+    print!(
+        "{}",
+        message(
+            "setup-complete",
+            &[
+                ("dialect", args.dialect.name()),
+                ("migrationsPath", &args.migrations_path),
+                (
+                    "createExample",
+                    &format!(
+                        "  cargo run --release --bin migrate-create -- --provider {} --name add_users",
+                        args.dialect.name()
+                    ),
+                ),
+                (
+                    "upExample",
+                    &format!(
+                        "  cargo run --release --bin migrate-up -- --provider {} --connection {}",
+                        args.dialect.name(),
+                        args.connection
+                    ),
+                ),
+            ],
+        )
+    );
+    if args.and_up {
+        let names = migrater
+            .up(UpArg {
+                connection: &args.connection,
+                migrations_path: &args.migrations_path,
+                one: false,
+            })
+            .await?;
+        if names.is_empty() {
+            print!("{}", message("status/no-pending", &[]));
+        } else {
+            for name in &names {
+                print!("{}", message("status/applied", &[("name", name)]));
+            }
+            print!("{}", message("status/no-more-pending", &[]));
+        }
+    }
+    Ok(())
+}

package/rust/src/bin/migrate_up.rs

@@ -0,0 +1,126 @@
+// Default: applies ALL pending migrations in sequence, each in its own transaction. Pass --one to apply only the next pending migration (legacy one-shot behavior; useful when wrapping in an external loop or when you want to inspect state between steps).
+
+use std::env;
+use std::process;
+
+use deterministic_migraters::{
+    connection_from_env, fill_help_template, is_help, join_env_vars, message, take_value, try_get,
+    IMigrater, Migrater, SqlDialect, UpArg,
+};
+
+const HELP_TEMPLATE: &str = include_str!("../../../shared/templates/help/up.txt");
+
+fn help_text() -> String {
+    fill_help_template(HELP_TEMPLATE, "migrate-up")
+}
+
+struct Args {
+    dialect: &'static dyn SqlDialect,
+    migrate_path: String,
+    connection: String,
+    one: bool,
+}
+
+fn parse_args() -> Result<Args, String> {
+    let mut provider: Option<String> = None;
+    let mut migrate_path: Option<String> = None;
+    let mut migrate_root: Option<String> = None;
+    let mut connection: Option<String> = None;
+    let mut one = false;
+    let mut iter = env::args().skip(1);
+    while let Some(a) = iter.next() {
+        if is_help(&a) {
+            eprint!("{}", help_text());
+            process::exit(0);
+        }
+        if a == "--one" {
+            one = true;
+            continue;
+        }
+        if let Some(v) = take_value(&a, &mut iter, "--provider") {
+            provider = Some(v);
+        } else if let Some(v) = take_value(&a, &mut iter, "--migrations-path")
+            .or_else(|| take_value(&a, &mut iter, "--migrate-path"))
+        {
+            migrate_path = Some(v);
+        } else if let Some(v) = take_value(&a, &mut iter, "--migrations-root")
+            .or_else(|| take_value(&a, &mut iter, "--migrate-root"))
+        {
+            migrate_root = Some(v);
+        } else if let Some(v) = take_value(&a, &mut iter, "--connection") {
+            connection = 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 migrate_path = migrate_path.unwrap_or_else(|| {
+        let root = migrate_root.unwrap_or_else(|| "sql".to_string());
+        format!("{}/{}/migrations", root, dialect.name())
+    });
+    let connection = match connection.or_else(|| connection_from_env(dialect)) {
+        Some(c) => c,
+        None => {
+            return Err(message(
+                "errors/missing-connection",
+                &[("envVars", &join_env_vars(dialect.connection_env_vars()))],
+            ))
+        }
+    };
+    Ok(Args {
+        dialect,
+        migrate_path,
+        connection,
+        one,
+    })
+}
+
+async fn apply_pending(args: &Args) -> Result<(), Box<dyn std::error::Error>> {
+    let names = Migrater::new(args.dialect)
+        .up(UpArg {
+            connection: &args.connection,
+            migrations_path: &args.migrate_path,
+            one: args.one,
+        })
+        .await?;
+    if names.is_empty() {
+        print!("{}", message("status/no-pending", &[]));
+        return Ok(());
+    }
+    for name in &names {
+        print!("{}", message("status/applied", &[("name", name)]));
+    }
+    if !args.one {
+        print!("{}", message("status/no-more-pending", &[]));
+    }
+    Ok(())
+}
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    match dotenvy::from_path(".env") {
+        Ok(()) => {}
+        Err(dotenvy::Error::Io(err)) if err.kind() == std::io::ErrorKind::NotFound => {}
+        Err(err) => return Err(format!("failed to load .env: {err}").into()),
+    }
+    let args = match parse_args() {
+        Ok(a) => a,
+        Err(msg) => {
+            eprintln!("{}", msg);
+            process::exit(2);
+        }
+    };
+    if let Some(msg) = args.dialect.prerequisite_error(&args.connection) {
+        eprintln!("{}", msg);
+        process::exit(2);
+    }
+    apply_pending(&args).await
+}

package/rust/src/checksum.rs

@@ -0,0 +1,55 @@
+use sha2::{Digest, Sha256};
+
+pub fn checksum_hex(sql: &str) -> String {
+    let body = strip_legacy_header(sql);
+    let digest = Sha256::digest(body.as_bytes());
+    digest.iter().map(|b| format!("{b:02x}")).collect()
+}
+
+fn strip_legacy_header(sql: &str) -> &str {
+    let first = match sql.split_inclusive('\n').next() {
+        Some(line) => line,
+        None => return sql,
+    };
+    if !is_legacy_header(first.trim_end_matches(['\r', '\n'])) {
+        return sql;
+    }
+    sql.get(first.len()..).unwrap_or("")
+}
+
+fn is_legacy_header(line: &str) -> bool {
+    for prefix in ["//", "--", "#"] {
+        let Some(rest) = line.strip_prefix(prefix) else {
+            continue;
+        };
+        let rest = rest.trim_start();
+        let Some(after) = rest.strip_prefix("deterministic-content-hash:") else {
+            continue;
+        };
+        let hex = after.trim();
+        if hex.len() == 64 && hex.bytes().all(|b| b.is_ascii_hexdigit()) {
+            return true;
+        }
+    }
+    false
+}
+
+#[cfg(test)]
+mod tests {
+    use super::checksum_hex;
+
+    #[test]
+    fn sha256_is_64_hex_chars() {
+        let hex = checksum_hex("SELECT 1;");
+        assert_eq!(hex.len(), 64);
+        assert!(hex.bytes().all(|b| b.is_ascii_hexdigit()));
+    }
+
+    #[test]
+    fn strips_legacy_header() {
+        let body = "CREATE TABLE t (id INT);\n";
+        let hash = "a".repeat(64);
+        let headed = format!("-- deterministic-content-hash: {hash}\n{body}");
+        assert_eq!(checksum_hex(&headed), checksum_hex(body));
+    }
+}