update

Author: cchexcode

Cargo.lock

@@ -40,6 +40,7 @@ toml = "0.9.2"
 sqlx = { version = "0.8.6", features = ["runtime-tokio", "postgres", "chrono"]}
 comfy-table = "7.1.1"
 path-clean = "1.0.1"
+sqlparser = "0.49"
 
 [dev-dependencies]
 hoox = "0.3.0"

Cargo.toml

@@ -1 +1,13 @@
--- SQL goes here
+ALTER TABLE "ASD" ADD COLUMN "ASD" TEXT FOREIGN KEY REFERENCES "X"("Y");
+DROP TABLE "boosker";-- This is a header comment
+ALTER TABLE "users" ADD COLUMN "email" TEXT; -- inline comment
+
+/* 
+Multi-line comment
+*/
+DROP TABLE "old_table";
+
+CREATE TABLE "new_table" (
+    id SERIAL PRIMARY KEY, -- column comment
+    name VARCHAR(255) /* another inline comment */
+);

example/id=1753311846662/up.sql

@@ -30,6 +30,9 @@ impl CallArgs {
         }
 
         match &self.command {
+            | Command::Migration(Migration { command: MigrationCommand::Diff, .. }) => anyhow::bail!("diff is experimental"),
+            | Command::Migration(Migration { command: MigrationCommand::Up { diff: true, .. }, .. }) => anyhow::bail!("diff is experimental"),
+            | Command::Migration(Migration { command: MigrationCommand::Down { diff: true, .. }, .. }) => anyhow::bail!("diff is experimental"),
             | _ => (),
         }
 
@@ -57,16 +60,19 @@ pub(crate) enum MigrationCommand {
     Up {
         timeout: Option<u64>,
         count: Option<usize>,
+        diff: bool,
     },
     Down {
         timeout: Option<u64>,
         count: Option<usize>,
         remote: bool,
+        diff: bool,
     },
     Apply(MigrationApply),
     List,
     Sync,
     Fix,
+    Diff,
 }
 
 #[derive(Debug)]
@@ -161,14 +167,16 @@ impl ClapArgumentLoader {
                         clap::Command::new("up")
                             .about("Runs the migrations.")
                             .arg(clap::Arg::new("timeout").short('t').long("timeout").required(false))
-                            .arg(clap::Arg::new("count").short('c').long("count").required(false)),
+                            .arg(clap::Arg::new("count").short('c').long("count").required(false))
+                            .arg(clap::Arg::new("diff").short('d').long("diff").required(false).num_args(0).help("Show migration diff before applying")),
                     )
                     .subcommand(
                         clap::Command::new("down")
                             .about("Rolls back the migrations.")
                             .arg(clap::Arg::new("timeout").short('t').long("timeout").required(false))
                             .arg(clap::Arg::new("remote").short('r').long("remote").required(false).num_args(0))
-                            .arg(clap::Arg::new("count").short('c').long("count").required(false)),
+                            .arg(clap::Arg::new("count").short('c').long("count").required(false))
+                            .arg(clap::Arg::new("diff").short('d').long("diff").required(false).num_args(0).help("Show migration diff before applying")),
                     )
                     .subcommand(
                         clap::Command::new("list")
@@ -182,6 +190,10 @@ impl ClapArgumentLoader {
                         clap::Command::new("fix")
                             .about("Shuffles all non-run local migrations to the end of the chain."),
                     )
+                    .subcommand(
+                        clap::Command::new("diff")
+                            .about("Shows pending migration operations without applying them."),
+                    )
                     .subcommand(
                         clap::Command::new("apply")
                             .about("Applies or reverts a specific migration by ID.")
@@ -240,19 +252,23 @@ impl ClapArgumentLoader {
                 MigrationCommand::Up {
                     timeout: up_subc.get_one::<String>("timeout").map(|s| s.parse::<u64>().unwrap()),
                     count: up_subc.get_one::<String>("count").map(|s| s.parse::<usize>().unwrap()),
+                    diff: up_subc.get_flag("diff"),
                 }
             } else if let Some(down_subc) = subc.subcommand_matches("down") {
                 MigrationCommand::Down {
                     timeout: down_subc.get_one::<String>("timeout").map(|s| s.parse::<u64>().unwrap()),
                     count: down_subc.get_one::<String>("count").map(|s| s.parse::<usize>().unwrap()),
                     remote: down_subc.get_flag("remote"),
+                    diff: down_subc.get_flag("diff"),
                 }
             } else if let Some(_) = subc.subcommand_matches("list") {
                 MigrationCommand::List
             } else if let Some(_) = subc.subcommand_matches("sync") {
                 MigrationCommand::Sync
             } else if let Some(_) = subc.subcommand_matches("fix") {
                 MigrationCommand::Fix
+            } else if let Some(_) = subc.subcommand_matches("diff") {
+                MigrationCommand::Diff
             } else if let Some(apply_subc) = subc.subcommand_matches("apply") {
                 if let Some(up_subc) = apply_subc.subcommand_matches("up") {
                     MigrationCommand::Apply(MigrationApply::Up {

src/args.rs

@@ -5,15 +5,26 @@ pub struct Config {
     pub backend: Backend,
 }
 
+#[derive(Debug, Serialize, Deserialize)]
+pub struct PostgresMigrations {
+    pub timeout: Option<u64>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct PostgresConnection {
+    pub host: String,
+    pub port: u16,
+    pub username: Option<String>,
+    pub password: Option<String>,
+    pub database: String,
+}
+
 #[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum Backend {
     Postgres {
-        host: String,
-        port: u16,
-        username: Option<String>,
-        password: Option<String>,
-        database: String,
+        connection: PostgresConnection,
+        migrations: PostgresMigrations,
         schema: String,
         table: String,
     },