Revert the n last migrations

Author: theredfish

diesel_cli/src/cli.rs

@@ -22,33 +22,36 @@ pub fn build_cli() -> App<'static, 'static> {
             SubCommand::with_name("revert")
                 .about("Reverts the latest run migration")
                 .arg(
-                    Arg::with_name("REVERT_ALL")
-                        .long("all")
-                        .help("Reverts all migrations")
+                    Arg::with_name("REVERT_NUMBER")
+                        .long("number")
+                        .short("n")
+                        .help("Reverts the last migration files")
                         .long_help(
-                            "When this option is specified all migrations \
-                            will be reverted. Useful for testing your revert \
-                            scripts only.",
+                            "When this option is specified the last `n` migration files \
+                             will be reverted. By default revert the last one.",
                         )
-                )
+                        .takes_value(true)
+                        .required(true)
+                        .default_value("1"),
+                ),
         )
         .subcommand(
             SubCommand::with_name("redo")
                 .about(
                     "Reverts and re-runs the latest migration. Useful \
-                    for testing that a migration can in fact be reverted.",
+                     for testing that a migration can in fact be reverted.",
                 )
                 .arg(
                     Arg::with_name("REDO_ALL")
                         .long("all")
                         .help("Reverts and re-runs all migrations.")
                         .long_help(
                             "When this option is specified all migrations \
-                            will be reverts and re-runs. Useful for testing \
-                            that your migrations can be reverted and applied."
-                        )
-                )
-            )
+                             will be reverted and re-runs. Useful for testing \
+                             that your migrations can be reverted and applied.",
+                        ),
+                ),
+        )
         .subcommand(
             SubCommand::with_name("list")
                 .about("Lists all available migrations, marking those that have been applied."),

diesel_cli/src/main.rs

@@ -71,13 +71,23 @@ fn run_migration_command(matches: &ArgMatches) -> Result<(), Box<dyn Error>> {
             )?;
             regenerate_schema_if_file_specified(matches)?;
         }
-        ("revert", Some(_)) => {
+        ("revert", Some(args)) => {
             let database_url = database::database_url(matches);
             let dir = migrations_dir(matches).unwrap_or_else(handle_error);
-            call_with_conn!(
-                database_url,
-                migrations::revert_latest_migration_in_directory(&dir)
-            )?;
+
+            match args.value_of("REVERT_NUMBER") {
+                Some("all") => println!("Match on all files"),
+                Some(n) => {
+                    let x = n.parse::<i64>().unwrap_or_else(handle_error);
+
+                    call_with_conn!(
+                        database_url,
+                        migrations::revert_latest_migrations_in_directory(&dir, x)
+                    )?;
+                }
+                None => unreachable!("REVERT_NUMBER has a default value"),
+            }
+
             regenerate_schema_if_file_specified(matches)?;
         }
         ("redo", Some(_)) => {

diesel_cli/tests/migration_revert.rs

@@ -128,3 +128,54 @@ fn migration_revert_respects_migration_dir_from_diesel_toml() {
     );
     assert!(!db.table_exists("users"));
 }
+
+#[test]
+fn migration_revert_runs_the_last_two_migration_down() {
+    let p = project("migration_revert").folder("migrations").build();
+    let db = database(&p.database_url());
+
+    p.create_migration(
+        "2017-08-31-210424_create_customers",
+        "CREATE TABLE customers ( id INTEGER PRIMARY KEY )",
+        "DROP TABLE customers",
+    );
+
+    p.create_migration(
+        "2017-09-03-210424_create_contracts",
+        "CREATE TABLE contracts ( id INTEGER PRIMARY KEY )",
+        "DROP TABLE contracts",
+    );
+
+    p.create_migration(
+        "2017-09-12-210424_create_bills",
+        "CREATE TABLE bills ( id INTEGER PRIMARY KEY )",
+        "DROP TABLE bills",
+    );
+
+    // Make sure the project is setup
+    p.command("setup").run();
+
+    assert!(db.table_exists("customers"));
+    assert!(db.table_exists("contracts"));
+    assert!(db.table_exists("bills"));
+
+    // Reverts the last two migration files. The `contracts` and `bills` tables should be dropped.
+    // The `customers` table shouldn't be reverted.
+    let result = p
+        .command("migration")
+        .arg("revert")
+        .arg("-n")
+        .arg("2")
+        .run();
+
+    assert!(result.is_success(), "Result was unsuccessful {:?}", result);
+    assert!(
+        result.stdout().contains("Rolling back migration 2017-09-12-210424_create_bills\nRolling back migration 2017-09-03-210424_create_contracts"),
+        "Unexpected stdout {}",
+        result.stdout()
+    );
+
+    assert!(db.table_exists("customers"));
+    assert!(!db.table_exists("contracts"));
+    assert!(!db.table_exists("bills"));
+}

diesel_migrations/migrations_internals/src/connection.rs

@@ -1,7 +1,7 @@
 use diesel::deserialize::FromSql;
 use diesel::expression::bound::Bound;
 use diesel::expression::QueryMetadata;
-use diesel::helper_types::{max, Limit, Select};
+use diesel::helper_types::{max, Desc, Limit, Order, Select};
 use diesel::insertable::ColumnInsertValue;
 use diesel::prelude::*;
 use diesel::query_builder::{InsertStatement, QueryFragment, ValuesClause};
@@ -19,6 +19,7 @@ use super::schema::__diesel_schema_migrations::dsl::*;
 pub trait MigrationConnection: diesel::migration::MigrationConnection {
     fn previously_run_migration_versions(&self) -> QueryResult<HashSet<String>>;
     fn latest_run_migration_version(&self) -> QueryResult<Option<String>>;
+    fn latest_run_migration_versions(&self, number: i64) -> QueryResult<Vec<String>>;
     fn insert_new_migration(&self, version: &str) -> QueryResult<()>;
 }
 
@@ -38,6 +39,8 @@ where
     Select<__diesel_schema_migrations, version>: LoadQuery<T, String>,
     Limit<Select<__diesel_schema_migrations, max<version>>>: QueryFragment<T::Backend>,
     T::Backend: QueryMetadata<Nullable<VarChar>>,
+    Order<Limit<Select<__diesel_schema_migrations, version>>, Desc<version>>:
+        QueryFragment<T::Backend>,
 {
     fn previously_run_migration_versions(&self) -> QueryResult<HashSet<String>> {
         __diesel_schema_migrations
@@ -51,6 +54,14 @@ where
         __diesel_schema_migrations.select(max(version)).first(self)
     }
 
+    fn latest_run_migration_versions(&self, number: i64) -> QueryResult<Vec<String>> {
+        __diesel_schema_migrations
+            .select(version)
+            .order(version.desc())
+            .limit(number)
+            .load(self)
+    }
+
     fn insert_new_migration(&self, ver: &str) -> QueryResult<()> {
         ::diesel::insert_into(__diesel_schema_migrations)
             .values(&version.eq(ver))

diesel_migrations/migrations_internals/src/lib.rs

@@ -200,6 +200,43 @@ where
     Ok(pending)
 }
 
+// TODO : see if we need a function named revert_latest_migrations
+// to call this one.
+pub fn revert_latest_migrations_in_directory<Conn>(
+    conn: &Conn,
+    path: &Path,
+    number: i64,
+) -> Result<Vec<String>, RunMigrationsError>
+where
+    Conn: MigrationConnection,
+{
+    setup_database(conn)?;
+
+    let latest_migration_versions = match conn.latest_run_migration_versions(number) {
+        Ok(migration_versions) => migration_versions,
+        Err(_) => {
+            return Err(RunMigrationsError::MigrationError(
+                MigrationError::NoMigrationRun,
+            ))
+        }
+    };
+
+    if latest_migration_versions.is_empty() {
+        return Err(RunMigrationsError::MigrationError(
+            MigrationError::NoMigrationRun,
+        ));
+    }
+
+    for migration_version in &latest_migration_versions {
+        // TODO see how to handle the errors... even if these errors
+        // are displayed on stdout.
+        revert_migration_with_version(conn, path, &migration_version, &mut stdout())
+            .unwrap_or_else(|_| ());
+    }
+
+    Ok(latest_migration_versions)
+}
+
 /// Reverts the last migration that was run. Returns the version that was reverted. Returns an
 /// `Err` if no migrations have ever been run.
 ///