strong_migrations 1.4.4 → 1.6.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7444023bd5f0829a289ebc9d222a28f041a4e3789224438f9fd6bffa01fa6668
-  data.tar.gz: feb5010616cc8ef6cf36088be7a67bb0d74272cde79d0e9a0a442272bfa92d99
+  metadata.gz: 5399a374f21a5e61350adbe125184d43664bc654cd1583804e7b01c9d6240aab
+  data.tar.gz: 71e638db667d72b1fdf433eb27cc4f382a6472bd0f75885f5ae244990c1b768a
 SHA512:
-  metadata.gz: '0599a3fef628ec724471ef53b7ad7358831e6b638bdd0ca3b7cb79c1b416da6c044793ecca5475f5e602e8a7d1235ced3ff3fda526f31b9c4a56990c8531f9b4'
-  data.tar.gz: 6aac91ecb348c6a04c25511adf7df5d3e97823f6b9acdfbfd86bac50c4f5856f15fdcc271f00d0fc6f1e5d2cfdbaf3da5e056b1476aaf9b224e7df89b9737e01
+  metadata.gz: 4c8dbc405cb94e4b8eb92a08161cb8689996e7a6ba216b326db27a83151f5dd796d53c42e5b4dd2f8e0cb224f3f6c8f94ff81edd23063438a8143f0d36c507b9
+  data.tar.gz: 532f43609d8006f71e325a708a74c45df8161d5957a5173701c77cc22e7dd3111562cbc70b715c6f94c955d08cda0fd43cfc577b9d902cda8a9e1fedcd4693cc

data/CHANGELOG.md

@@ -1,3 +1,29 @@
+## 1.6.4 (2023-10-17)
+
+- Fixed false positives with `revert`
+
+## 1.6.3 (2023-09-20)
+
+- Added support for Trilogy
+
+## 1.6.2 (2023-09-13)
+
+- Fixed foreign key options with `add_reference` and `safe_by_default`
+- Fixed `safety_assured` with `revert`
+
+## 1.6.1 (2023-08-09)
+
+- Fixed `safety_assured` for custom checks with `safe_by_default`
+
+## 1.6.0 (2023-07-22)
+
+- Added check for `change_column_default`
+
+## 1.5.0 (2023-07-02)
+
+- Added check for `add_column` with stored generated columns
+- Fixed `add_reference` with `foreign_key` and `index: false`
+
 ## 1.4.4 (2023-03-08)
 
 - Fixed `add_foreign_key` with `name` and `column` options with `safe_by_default`
@@ -219,7 +245,7 @@ Other
 ## 0.2.2 (2018-02-14)
 
 - Friendlier output
-- Better method of hooking into ActiveRecord
+- Better method of hooking into Active Record
 
 ## 0.2.1 (2018-02-07)
 

data/README.md

@@ -43,7 +43,7 @@ end
 
 Deploy the code, then wrap this step in a safety_assured { ... } block.
 
-class RemoveColumn < ActiveRecord::Migration[7.0]
+class RemoveColumn < ActiveRecord::Migration[7.1]
   def change
     safety_assured { remove_column :users, :name }
   end
@@ -62,6 +62,7 @@ Potentially dangerous operations:
 - [removing a column](#removing-a-column)
 - [adding a column with a default value](#adding-a-column-with-a-default-value)
 - [backfilling data](#backfilling-data)
+- [adding a stored generated column](#adding-a-stored-generated-column)
 - [changing the type of a column](#changing-the-type-of-a-column)
 - [renaming a column](#renaming-a-column)
 - [renaming a table](#renaming-a-table)
@@ -78,6 +79,10 @@ Postgres-specific checks:
 - [adding a json column](#adding-a-json-column)
 - [setting NOT NULL on an existing column](#setting-not-null-on-an-existing-column)
 
+Config-specific checks:
+
+- [changing the default value of a column](#changing-the-default-value-of-a-column)
+
 Best practices:
 
 - [keeping non-unique indexes to three columns or less](#keeping-non-unique-indexes-to-three-columns-or-less)
@@ -91,7 +96,7 @@ You can also add [custom checks](#custom-checks) or [disable specific checks](#d
 Active Record caches database columns at runtime, so if you drop a column, it can cause exceptions until your app reboots.
 
 ```ruby
-class RemoveSomeColumnFromUsers < ActiveRecord::Migration[7.0]
+class RemoveSomeColumnFromUsers < ActiveRecord::Migration[7.1]
   def change
     remove_column :users, :some_column
   end
@@ -112,7 +117,7 @@ end
 3. Write a migration to remove the column (wrap in `safety_assured` block)
 
   ```ruby
-  class RemoveSomeColumnFromUsers < ActiveRecord::Migration[7.0]
+  class RemoveSomeColumnFromUsers < ActiveRecord::Migration[7.1]
     def change
       safety_assured { remove_column :users, :some_column }
     end
@@ -129,7 +134,7 @@ end
 In earlier versions of Postgres, MySQL, and MariaDB, adding a column with a default value to an existing table causes the entire table to be rewritten. During this time, reads and writes are blocked in Postgres, and writes are blocked in MySQL and MariaDB.
 
 ```ruby
-class AddSomeColumnToUsers < ActiveRecord::Migration[7.0]
+class AddSomeColumnToUsers < ActiveRecord::Migration[7.1]
   def change
     add_column :users, :some_column, :text, default: "default_value"
   end
@@ -143,7 +148,7 @@ In Postgres 11+, MySQL 8.0.12+, and MariaDB 10.3.2+, this no longer requires a t
 Instead, add the column without a default value, then change the default.
 
 ```ruby
-class AddSomeColumnToUsers < ActiveRecord::Migration[7.0]
+class AddSomeColumnToUsers < ActiveRecord::Migration[7.1]
   def up
     add_column :users, :some_column, :text
     change_column_default :users, :some_column, "default_value"
@@ -164,7 +169,7 @@ See the next section for how to backfill.
 Active Record creates a transaction around each migration, and backfilling in the same transaction that alters a table keeps the table locked for the [duration of the backfill](https://wework.github.io/data/2015/11/05/add-columns-with-default-values-to-large-tables-in-rails-postgres/).
 
 ```ruby
-class AddSomeColumnToUsers < ActiveRecord::Migration[7.0]
+class AddSomeColumnToUsers < ActiveRecord::Migration[7.1]
   def change
     add_column :users, :some_column, :text
     User.update_all some_column: "default_value"
@@ -179,7 +184,7 @@ Also, running a single query to update data can cause issues for large tables.
 There are three keys to backfilling safely: batching, throttling, and running it outside a transaction. Use the Rails console or a separate migration with `disable_ddl_transaction!`.
 
 ```ruby
-class BackfillSomeColumn < ActiveRecord::Migration[7.0]
+class BackfillSomeColumn < ActiveRecord::Migration[7.1]
   disable_ddl_transaction!
 
   def up
@@ -191,6 +196,24 @@ class BackfillSomeColumn < ActiveRecord::Migration[7.0]
 end
 ```
 
+### Adding a stored generated column
+
+#### Bad
+
+Adding a stored generated column causes the entire table to be rewritten. During this time, reads and writes are blocked in Postgres, and writes are blocked in MySQL and MariaDB.
+
+```ruby
+class AddSomeColumnToUsers < ActiveRecord::Migration[7.1]
+  def change
+    add_column :users, :some_column, :virtual, type: :string, as: "...", stored: true
+  end
+end
+```
+
+#### Good
+
+Add a non-generated column and use callbacks or triggers instead (or a virtual generated column with MySQL and MariaDB).
+
 ### Changing the type of a column
 
 #### Bad
@@ -198,7 +221,7 @@ end
 Changing the type of a column causes the entire table to be rewritten. During this time, reads and writes are blocked in Postgres, and writes are blocked in MySQL and MariaDB.
 
 ```ruby
-class ChangeSomeColumnType < ActiveRecord::Migration[7.0]
+class ChangeSomeColumnType < ActiveRecord::Migration[7.1]
   def change
     change_column :users, :some_column, :new_type
   end
@@ -244,7 +267,7 @@ A safer approach is to:
 Renaming a column that’s in use will cause errors in your application.
 
 ```ruby
-class RenameSomeColumn < ActiveRecord::Migration[7.0]
+class RenameSomeColumn < ActiveRecord::Migration[7.1]
   def change
     rename_column :users, :some_column, :new_name
   end
@@ -269,7 +292,7 @@ A safer approach is to:
 Renaming a table that’s in use will cause errors in your application.
 
 ```ruby
-class RenameUsersToCustomers < ActiveRecord::Migration[7.0]
+class RenameUsersToCustomers < ActiveRecord::Migration[7.1]
   def change
     rename_table :users, :customers
   end
@@ -294,7 +317,7 @@ A safer approach is to:
 The `force` option can drop an existing table.
 
 ```ruby
-class CreateUsers < ActiveRecord::Migration[7.0]
+class CreateUsers < ActiveRecord::Migration[7.1]
   def change
     create_table :users, force: true do |t|
       # ...
@@ -308,7 +331,7 @@ end
 Create tables without the `force` option.
 
 ```ruby
-class CreateUsers < ActiveRecord::Migration[7.0]
+class CreateUsers < ActiveRecord::Migration[7.1]
   def change
     create_table :users do |t|
       # ...
@@ -328,7 +351,7 @@ If you intend to drop an existing table, run `drop_table` first.
 Adding a check constraint blocks reads and writes in Postgres and blocks writes in MySQL and MariaDB while every row is checked.
 
 ```ruby
-class AddCheckConstraint < ActiveRecord::Migration[7.0]
+class AddCheckConstraint < ActiveRecord::Migration[7.1]
   def change
     add_check_constraint :users, "price > 0", name: "price_check"
   end
@@ -340,7 +363,7 @@ end
 Add the check constraint without validating existing rows:
 
 ```ruby
-class AddCheckConstraint < ActiveRecord::Migration[7.0]
+class AddCheckConstraint < ActiveRecord::Migration[7.1]
   def change
     add_check_constraint :users, "price > 0", name: "price_check", validate: false
   end
@@ -350,7 +373,7 @@ end
 Then validate them in a separate migration.
 
 ```ruby
-class ValidateCheckConstraint < ActiveRecord::Migration[7.0]
+class ValidateCheckConstraint < ActiveRecord::Migration[7.1]
   def change
     validate_check_constraint :users, name: "price_check"
   end
@@ -366,7 +389,7 @@ end
 Strong Migrations can’t ensure safety for raw SQL statements. Make really sure that what you’re doing is safe, then use:
 
 ```ruby
-class ExecuteSQL < ActiveRecord::Migration[7.0]
+class ExecuteSQL < ActiveRecord::Migration[7.1]
   def change
     safety_assured { execute "..." }
   end
@@ -382,7 +405,7 @@ end
 In Postgres, adding an index non-concurrently blocks writes.
 
 ```ruby
-class AddSomeIndexToUsers < ActiveRecord::Migration[7.0]
+class AddSomeIndexToUsers < ActiveRecord::Migration[7.1]
   def change
     add_index :users, :some_column
   end
@@ -394,7 +417,7 @@ end
 Add indexes concurrently.
 
 ```ruby
-class AddSomeIndexToUsers < ActiveRecord::Migration[7.0]
+class AddSomeIndexToUsers < ActiveRecord::Migration[7.1]
   disable_ddl_transaction!
 
   def change
@@ -420,7 +443,7 @@ rails g index table column
 Rails adds an index non-concurrently to references by default, which blocks writes in Postgres.
 
 ```ruby
-class AddReferenceToUsers < ActiveRecord::Migration[7.0]
+class AddReferenceToUsers < ActiveRecord::Migration[7.1]
   def change
     add_reference :users, :city
   end
@@ -432,7 +455,7 @@ end
 Make sure the index is added concurrently.
 
 ```ruby
-class AddReferenceToUsers < ActiveRecord::Migration[7.0]
+class AddReferenceToUsers < ActiveRecord::Migration[7.1]
   disable_ddl_transaction!
 
   def change
@@ -450,7 +473,7 @@ end
 In Postgres, adding a foreign key blocks writes on both tables.
 
 ```ruby
-class AddForeignKeyOnUsers < ActiveRecord::Migration[7.0]
+class AddForeignKeyOnUsers < ActiveRecord::Migration[7.1]
   def change
     add_foreign_key :users, :orders
   end
@@ -460,7 +483,7 @@ end
 or
 
 ```ruby
-class AddReferenceToUsers < ActiveRecord::Migration[7.0]
+class AddReferenceToUsers < ActiveRecord::Migration[7.1]
   def change
     add_reference :users, :order, foreign_key: true
   end
@@ -472,7 +495,7 @@ end
 Add the foreign key without validating existing rows:
 
 ```ruby
-class AddForeignKeyOnUsers < ActiveRecord::Migration[7.0]
+class AddForeignKeyOnUsers < ActiveRecord::Migration[7.1]
   def change
     add_foreign_key :users, :orders, validate: false
   end
@@ -482,7 +505,7 @@ end
 Then validate them in a separate migration.
 
 ```ruby
-class ValidateForeignKeyOnUsers < ActiveRecord::Migration[7.0]
+class ValidateForeignKeyOnUsers < ActiveRecord::Migration[7.1]
   def change
     validate_foreign_key :users, :orders
   end
@@ -514,7 +537,7 @@ end
 In Postgres, there’s no equality operator for the `json` column type, which can cause errors for existing `SELECT DISTINCT` queries in your application.
 
 ```ruby
-class AddPropertiesToUsers < ActiveRecord::Migration[7.0]
+class AddPropertiesToUsers < ActiveRecord::Migration[7.1]
   def change
     add_column :users, :properties, :json
   end
@@ -526,7 +549,7 @@ end
 Use `jsonb` instead.
 
 ```ruby
-class AddPropertiesToUsers < ActiveRecord::Migration[7.0]
+class AddPropertiesToUsers < ActiveRecord::Migration[7.1]
   def change
     add_column :users, :properties, :jsonb
   end
@@ -542,7 +565,7 @@ end
 In Postgres, setting `NOT NULL` on an existing column blocks reads and writes while every row is checked.
 
 ```ruby
-class SetSomeColumnNotNull < ActiveRecord::Migration[7.0]
+class SetSomeColumnNotNull < ActiveRecord::Migration[7.1]
   def change
     change_column_null :users, :some_column, false
   end
@@ -553,10 +576,10 @@ end
 
 Instead, add a check constraint.
 
-For Rails 6.1, use:
+For Rails 6.1+, use:
 
 ```ruby
-class SetSomeColumnNotNull < ActiveRecord::Migration[7.0]
+class SetSomeColumnNotNull < ActiveRecord::Migration[7.1]
   def change
     add_check_constraint :users, "some_column IS NOT NULL", name: "users_some_column_null", validate: false
   end
@@ -577,10 +600,10 @@ end
 
 Then validate it in a separate migration. A `NOT NULL` check constraint is [functionally equivalent](https://medium.com/doctolib/adding-a-not-null-constraint-on-pg-faster-with-minimal-locking-38b2c00c4d1c) to setting `NOT NULL` on the column (but it won’t show up in `schema.rb` in Rails < 6.1). In Postgres 12+, once the check constraint is validated, you can safely set `NOT NULL` on the column and drop the check constraint.
 
-For Rails 6.1, use:
+For Rails 6.1+, use:
 
 ```ruby
-class ValidateSomeColumnNotNull < ActiveRecord::Migration[7.0]
+class ValidateSomeColumnNotNull < ActiveRecord::Migration[7.1]
   def change
     validate_check_constraint :users, name: "users_some_column_null"
 
@@ -609,6 +632,36 @@ class ValidateSomeColumnNotNull < ActiveRecord::Migration[6.0]
 end
 ```
 
+### Changing the default value of a column
+
+#### Bad
+
+Rails < 7 enables partial writes by default, which can cause incorrect values to be inserted when changing the default value of a column.
+
+```ruby
+class ChangeSomeColumnDefault < ActiveRecord::Migration[6.1]
+  def change
+    change_column_default :users, :some_column, from: "old", to: "new"
+  end
+end
+
+User.create!(some_column: "old") # can insert "new"
+```
+
+#### Good
+
+Disable partial writes in `config/application.rb`. For Rails < 7, use:
+
+```ruby
+config.active_record.partial_writes = false
+```
+
+For Rails 7+, use:
+
+```ruby
+config.active_record.partial_inserts = false
+```
+
 ### Keeping non-unique indexes to three columns or less
 
 #### Bad
@@ -616,7 +669,7 @@ end
 Adding a non-unique index with more than three columns rarely improves performance.
 
 ```ruby
-class AddSomeIndexToUsers < ActiveRecord::Migration[7.0]
+class AddSomeIndexToUsers < ActiveRecord::Migration[7.1]
   def change
     add_index :users, [:a, :b, :c, :d]
   end
@@ -628,7 +681,7 @@ end
 Instead, start an index with columns that narrow down the results the most.
 
 ```ruby
-class AddSomeIndexToUsers < ActiveRecord::Migration[7.0]
+class AddSomeIndexToUsers < ActiveRecord::Migration[7.1]
   def change
     add_index :users, [:b, :d]
   end
@@ -642,7 +695,7 @@ For Postgres, be sure to add them concurrently.
 To mark a step in the migration as safe, despite using a method that might otherwise be dangerous, wrap it in a `safety_assured` block.
 
 ```ruby
-class MySafeMigration < ActiveRecord::Migration[7.0]
+class MySafeMigration < ActiveRecord::Migration[7.1]
   def change
     safety_assured { remove_column :users, :some_column }
   end
@@ -740,25 +793,6 @@ ALTER ROLE myuser SET statement_timeout = '1h';
 
 Note: If you use PgBouncer in transaction mode, you must set timeouts on the database user.
 
-## Lock Timeout Retries [experimental]
-
-There’s the option to automatically retry statements when the lock timeout is reached. Here’s how it works:
-
-- If a lock timeout happens outside a transaction, the statement is retried
-- If it happens inside the DDL transaction, the entire migration is retried (only applicable to Postgres)
-
-Add to `config/initializers/strong_migrations.rb`:
-
-```ruby
-StrongMigrations.lock_timeout_retries = 3
-```
-
-Set the delay between retries with:
-
-```ruby
-StrongMigrations.lock_timeout_retry_delay = 10.seconds
-```
-
 ## App Timeouts
 
 We recommend adding timeouts to `config/database.yml` to prevent connections from hanging and individual queries from taking up too many resources in controllers, jobs, the Rails console, and other places.
@@ -802,12 +836,31 @@ production:
 
 For HTTP connections, Redis, and other services, check out [this guide](https://github.com/ankane/the-ultimate-guide-to-ruby-timeouts).
 
+## Lock Timeout Retries [experimental]
+
+There’s the option to automatically retry statements for migrations when the lock timeout is reached. Here’s how it works:
+
+- If a lock timeout happens outside a transaction, the statement is retried
+- If it happens inside the DDL transaction, the entire migration is retried (only applicable to Postgres)
+
+Add to `config/initializers/strong_migrations.rb`:
+
+```ruby
+StrongMigrations.lock_timeout_retries = 3
+```
+
+Set the delay between retries with:
+
+```ruby
+StrongMigrations.lock_timeout_retry_delay = 10.seconds
+```
+
 ## Existing Migrations
 
 To mark migrations as safe that were created before installing this gem, create an initializer with:
 
 ```ruby
-StrongMigrations.start_after = 20170101000000
+StrongMigrations.start_after = 20230101000000
 ```
 
 Use the version from your latest migration.

data/lib/strong_migrations/checker.rb

@@ -5,21 +5,25 @@ module StrongMigrations
 
     attr_accessor :direction, :transaction_disabled, :timeouts_set
 
+    class << self
+      attr_accessor :safe
+    end
+
     def initialize(migration)
       @migration = migration
       @new_tables = []
-      @safe = false
+      @new_columns = []
       @timeouts_set = false
       @committed = false
     end
 
-    def safety_assured
-      previous_value = @safe
+    def self.safety_assured
+      previous_value = safe
       begin
-        @safe = true
+        self.safe = true
         yield
       ensure
-        @safe = previous_value
+        self.safe = previous_value
       end
     end
 
@@ -46,6 +50,8 @@ module StrongMigrations
           check_add_reference(method, *args)
         when :change_column
           check_change_column(*args)
+        when :change_column_default
+          check_change_column_default(*args)
         when :change_column_null
           check_change_column_null(*args)
         when :change_table
@@ -75,9 +81,11 @@ module StrongMigrations
           @committed = true
         end
 
-        # custom checks
-        StrongMigrations.checks.each do |check|
-          @migration.instance_exec(method, args, &check)
+        if !safe?
+          # custom checks
+          StrongMigrations.checks.each do |check|
+            @migration.instance_exec(method, args, &check)
+          end
         end
       end
 
@@ -115,6 +123,10 @@ module StrongMigrations
       end
     end
 
+    def version_safe?
+      version && version <= StrongMigrations.start_after
+    end
+
     private
 
     def check_version_supported
@@ -155,11 +167,7 @@ module StrongMigrations
     end
 
     def safe?
-      @safe || ENV["SAFETY_ASSURED"] || (direction == :down && !StrongMigrations.check_down) || version_safe?
-    end
-
-    def version_safe?
-      version && version <= StrongMigrations.start_after
+      self.class.safe || ENV["SAFETY_ASSURED"] || (direction == :down && !StrongMigrations.check_down) || version_safe? || @migration.reverting?
     end
 
     def version
@@ -172,7 +180,7 @@ module StrongMigrations
           case connection.adapter_name
           when /postg/i # PostgreSQL, PostGIS
             Adapters::PostgreSQLAdapter
-          when /mysql/i
+          when /mysql|trilogy/i
             if connection.try(:mariadb?)
               Adapters::MariaDBAdapter
             else

data/lib/strong_migrations/checks.rb

@@ -32,6 +32,9 @@ module StrongMigrations
       table, column, type = args
       default = options[:default]
 
+      # keep track of new columns of change_column_default check
+      @new_columns << [table.to_s, column.to_s]
+
       # Check key since DEFAULT NULL behaves differently from no default
       #
       # Also, Active Record has special case for uuid columns that allows function default values
@@ -71,6 +74,10 @@ Then add the NOT NULL constraint in separate migrations."
         raise_error :add_column_json,
           command: command_str("add_column", [table, column, :jsonb, options])
       end
+
+      if type.to_s == "virtual" && options[:stored]
+        raise_error :add_column_generated_stored, rewrite_blocks: adapter.rewrite_blocks
+      end
     end
 
     def check_add_exclusion_constraint(*args)
@@ -147,7 +154,7 @@ Then add the NOT NULL constraint in separate migrations."
         if bad_index || options[:foreign_key]
           if index_value.is_a?(Hash)
             options[:index] = options[:index].merge(algorithm: :concurrently)
-          else
+          elsif index_value
             options = options.merge(index: {algorithm: :concurrently})
           end
 
@@ -194,6 +201,18 @@ Then add the foreign key in separate migrations."
       raise_error :change_column, rewrite_blocks: adapter.rewrite_blocks unless safe
     end
 
+    def check_change_column_default(*args)
+      table, column, _default_or_changes = args
+
+      # just check ActiveRecord::Base, even though can override on model
+      partial_inserts = ar_version >= 7 ? ActiveRecord::Base.partial_inserts : ActiveRecord::Base.partial_writes
+
+      if partial_inserts && !new_column?(table, column)
+        raise_error :change_column_default,
+          config: ar_version >= 7 ? "partial_inserts" : "partial_writes"
+      end
+    end
+
     def check_change_column_null(*args)
       table, column, null, default = args
       if !null
@@ -456,5 +475,9 @@ Then add the foreign key in separate migrations."
     def new_table?(table)
       @new_tables.include?(table.to_s)
     end
+
+    def new_column?(table, column)
+      new_table?(table) || @new_columns.include?([table.to_s, column.to_s])
+    end
   end
 end

data/lib/strong_migrations/error_messages.rb

@@ -50,6 +50,9 @@ class %{migration_name} < ActiveRecord::Migration%{migration_suffix}
   end
 end",
 
+    add_column_generated_stored:
+"Adding a stored generated column blocks %{rewrite_blocks} while the entire table is rewritten.",
+
     change_column:
 "Changing the type of an existing column blocks %{rewrite_blocks}
 while the entire table is rewritten. A safer approach is to:
@@ -158,6 +161,13 @@ Otherwise, remove the force option.",
 execute call, so cannot help you here. Please make really sure that what
 you're doing is safe before proceeding, then wrap it in a safety_assured { ... } block.",
 
+    change_column_default:
+"Partial writes are enabled, which can cause incorrect values
+to be inserted when changing the default value of a column.
+Disable partial writes in config/application.rb:
+
+config.active_record.%{config} = false",
+
     change_column_null:
 "Passing a default value to change_column_null runs a single UPDATE query,
 which can cause downtime. Instead, backfill the existing rows in the

data/lib/strong_migrations/migration.rb

@@ -20,8 +20,16 @@ module StrongMigrations
     end
     ruby2_keywords(:method_missing) if respond_to?(:ruby2_keywords, true)
 
+    def revert(*)
+      if strong_migrations_checker.version_safe?
+        safety_assured { super }
+      else
+        super
+      end
+    end
+
     def safety_assured
-      strong_migrations_checker.safety_assured do
+      strong_migrations_checker.class.safety_assured do
         yield
       end
     end

data/lib/strong_migrations/safe_methods.rb

@@ -30,10 +30,11 @@ module StrongMigrations
                 (ActiveRecord::Base.pluralize_table_names ? reference.to_s.pluralize : reference).to_sym
               end
 
+            foreign_key_opts = foreign_key.is_a?(Hash) ? foreign_key.except(:to_table) : {}
             if reference
-              @migration.add_foreign_key(table, name, column: "#{reference}_id")
+              @migration.add_foreign_key(table, name, column: "#{reference}_id", **foreign_key_opts)
             else
-              @migration.add_foreign_key(table, name)
+              @migration.add_foreign_key(table, name, **foreign_key_opts)
             end
           end
         end

data/lib/strong_migrations/version.rb

@@ -1,3 +1,3 @@
 module StrongMigrations
-  VERSION = "1.4.4"
+  VERSION = "1.6.4"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: strong_migrations
 version: !ruby/object:Gem::Version
-  version: 1.4.4
+  version: 1.6.4
 platform: ruby
 authors:
 - Andrew Kane
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-03-08 00:00:00.000000000 Z
+date: 2023-10-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -75,7 +75,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.6
+rubygems_version: 3.4.10
 signing_key:
 specification_version: 4
 summary: Catch unsafe migrations in development