migration up or down to the specific version

sea-orm-cli/src/commands.rs

@@ -248,19 +248,22 @@ pub fn run_migrate_command(matches: &ArgMatches<'_>) -> Result<(), Box<dyn Error
         update_migrator(&migration_name, migration_dir)?;
         return Ok(());
     }
-    let (subcommand, migration_dir, steps, verbose) = match migrate_subcommand {
+    let (subcommand, migration_dir, steps, version, force, verbose) = match migrate_subcommand {
         // Catch all command with pattern `migrate xxx`
         (subcommand, Some(args)) => {
             let migration_dir = args.value_of("MIGRATION_DIR").unwrap();
             let steps = args.value_of("NUM_MIGRATION");
+            let version = args.value_of("VERSION_MIGRATION");
+            let force = args.is_present("FORCE_MIGRATION");
             let verbose = args.is_present("VERBOSE");
-            (subcommand, migration_dir, steps, verbose)
+            (subcommand, migration_dir, steps, version, force, verbose)
         }
         // Catch command `migrate`, this will be treated as `migrate up`
         _ => {
             let migration_dir = matches.value_of("MIGRATION_DIR").unwrap();
             let verbose = matches.is_present("VERBOSE");
-            ("up", migration_dir, None, verbose)
+            let force = matches.is_present("FORCE_MIGRATION");
+            ("up", migration_dir, None, None, force, verbose)
         }
     };
     // Construct the `--manifest-path`
@@ -280,6 +283,12 @@ pub fn run_migrate_command(matches: &ArgMatches<'_>) -> Result<(), Box<dyn Error
     if let Some(steps) = steps {
         args.extend(["-n", steps]);
     }
+    if let Some(version) = version {
+        args.extend(["-V", version]);
+    }
+    if force {
+        args.push("-f");
+    }
     if verbose {
         args.push("-v");
     }

sea-orm-cli/src/migration.rs

@@ -34,8 +34,22 @@ pub fn get_subcommands() -> Vec<App<'static, 'static>> {
                     .short("n")
                     .help("Number of pending migrations to be applied")
                     .takes_value(true),
+            )
+            .arg(
+                Arg::with_name("VERSION_MIGRATION")
+                    .long("version")
+                    .short("V")
+                    .help("Version of pending migrations to be applied")
+                    .takes_value(true),
+            )
+            .arg(
+                Arg::with_name("FORCE_MIGRATION")
+                    .long("force")
+                    .short("f")
+                    .help("force version of pending migrations to be applied")
+                    .takes_value(false),
             ),
-        SubCommand::with_name("down")
+            SubCommand::with_name("down")
             .about("Rollback applied migrations")
             .arg(
                 Arg::with_name("NUM_MIGRATION")
@@ -44,6 +58,20 @@ pub fn get_subcommands() -> Vec<App<'static, 'static>> {
                     .help("Number of pending migrations to be rolled back")
                     .takes_value(true)
                     .default_value("1"),
+            )
+            .arg(
+                Arg::with_name("VERSION_MIGRATION")
+                    .long("version")
+                    .short("V")
+                    .help("Version of pending migrations to be rolled back")
+                    .takes_value(true),
+            )
+            .arg(
+                Arg::with_name("FORCE_MIGRATION")
+                    .long("force")
+                    .short("f")
+                    .help("force version of pending migrations to be rolled back")
+                    .takes_value(false),
             ),
     ]
 }

sea-orm-migration/src/cli.rs

@@ -60,14 +60,32 @@ where
         ("up", None) => M::up(db, None).await,
         ("down", None) => M::down(db, Some(1)).await,
         ("up", Some(args)) => {
-            let str = args.value_of("NUM_MIGRATION").unwrap_or_default();
-            let steps = str.parse().ok();
-            M::up(db, steps).await
+            let version = args.value_of("VERSION_MIGRATION");
+            if version.is_some() {
+                if args.is_present("FORCE_MIGRATION") {
+                    M::change_to_version(db, version.unwrap()).await
+                } else {
+                    M::up_to_version(db, version.unwrap()).await
+                }
+            } else {
+                let str = args.value_of("NUM_MIGRATION").unwrap_or_default();
+                let steps = str.parse().ok();
+                M::up(db, steps).await
+            }
         }
         ("down", Some(args)) => {
-            let str = args.value_of("NUM_MIGRATION").unwrap();
-            let steps = str.parse().ok().unwrap_or(1);
-            M::down(db, Some(steps)).await
+            let version = args.value_of("VERSION_MIGRATION");
+            if version.is_some() {
+                if args.is_present("FORCE_MIGRATION") {
+                    M::change_to_version(db, version.unwrap()).await
+                } else {
+                    M::down_to_version(db, version.unwrap()).await
+                }
+            } else {
+                let str = args.value_of("NUM_MIGRATION").unwrap();
+                let steps = str.parse().ok().unwrap_or(1);
+                M::down(db, Some(steps)).await
+            }
         }
         _ => M::up(db, None).await,
     }

sea-orm-migration/src/migrator.rs

@@ -289,6 +289,70 @@ pub trait MigratorTrait: Send {
 
         Ok(())
     }
+
+    /// Apply or Rollback migrations to version
+    async fn change_to_version(db: &DbConn, version: &str) -> Result<(), DbErr> {
+        Self::up_to_version(db, version).await?;
+        Self::down_to_version(db, version).await
+    }
+
+    /// Apply migrations to version
+    async fn up_to_version(db: &DbConn, version: &str) -> Result<(), DbErr> {
+        let steps = Self::get_steps(db, MigrationStatus::Pending, version).await?;
+        if steps > 0 {
+            Self::up(db, Some(steps)).await
+        } else {
+            Ok(())
+        }
+    }
+
+    /// Rollback migrations to version
+    async fn down_to_version(db: &DbConn, version: &str) -> Result<(), DbErr> {
+        let steps = Self::get_steps(db, MigrationStatus::Applied, version).await?;
+        if steps > 1 {
+            Self::down(db, Some(steps - 1)).await
+        } else {
+            Ok(())
+        }
+    }
+
+    async fn get_steps(db: &DbConn, status: MigrationStatus, version: &str) -> Result<u32, DbErr> {
+        let mut index = 0;
+        let mut matched = false;
+        let migrations = Self::get_migration_with_status(db).await?;
+        match status {
+            MigrationStatus::Pending => {
+                for migration in migrations {
+                    if migration.status == MigrationStatus::Pending {
+                        index += 1;
+                    }
+                    if migration.migration.name() == version {
+                        matched = true;
+                        break;
+                    }
+                }
+            }
+            MigrationStatus::Applied => {
+                for migration in migrations.into_iter().rev() {
+                    if migration.status == MigrationStatus::Applied {
+                        index += 1;
+                    }
+                    if migration.migration.name() == version {
+                        if migration.status == MigrationStatus::Pending {
+                            index += 1;
+                        }
+                        matched = true;
+                        break;
+                    }
+                }
+            }
+        }
+        if matched {
+            Ok(index)
+        } else {
+            Ok(0)
+        }
+    }
 }
 
 pub(crate) fn query_tables(db: &DbConn) -> SelectStatement {