strong_migrations 2.0.2 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 98ed2c92ee055824eefbb8239b65a6ef1c847b1ffa87e8cafb7fce34f8878c3c
-  data.tar.gz: 4f20acd9b50d07dfbe8ff6745f2fda6aaf7ca6731be72c8275929e15b12bd212
+  metadata.gz: c90bd33b534a7c37e59499e81b9c61e7d67a45bc849fd9dfe4d58285631438bf
+  data.tar.gz: 3771261014091caf3c28369db3ae4f97a1434d92b3207b351bf92c839caaec70
 SHA512:
-  metadata.gz: 492d1dec59fc74196c3670b8a49fcc080af36eb3297c1c9aabfea7f0ff1943c21a4fe43e66d0e406d4eae1b785223f3e137bf05ee377d5597e87573f7b7c7af4
-  data.tar.gz: 2a955f9eb53386c39678f48291603345be5d086877ce9a2fdd2f60dcc5eec84b671945fd9dba6a4f5d98d9d41da7cb32ab061daa333f461344ae7b9c7884c9d0
+  metadata.gz: aaa494cbbf0545df8795a5243d80f150e3be939507ab9379c20eb8b7cd68d5fde29c86cce63fffb005e3cd6ff5c858d084eb335bc7c911cccb4da751cfbbac32
+  data.tar.gz: b4833b425a23328795f14a6bcd94a4d06e11da5272976dfbeaaebcc469454b685058bc65c109561c513bc2434acf9119ecbae8b135b3c6d020d5ada607e86a38

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+## 2.1.0 (2024-11-08)
+
+- Added `skip_database` method
+- Added experimental `remove_invalid_indexes` option
+- Added warning for unsupported adapters
+- Improved output for `db:forward`, `db:rollback`, `db:migrate:up`, and `db:migrate:down`
+- Made operations more retriable with `safe_by_default`
+
 ## 2.0.2 (2024-10-30)
 
 - Fixed migrations not running with Active Record 8 rc2

data/README.md

@@ -351,6 +351,8 @@ end
 
 ### Backfilling data
 
+Note: Strong Migrations does not detect dangerous backfills.
+
 #### Bad
 
 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/).
@@ -383,6 +385,8 @@ class BackfillSomeColumn < ActiveRecord::Migration[7.2]
 end
 ```
 
+Note: If backfilling with a method other than `update_all`, use `User.reset_column_information` to ensure the model has up-to-date column information.
+
 ### Adding an index non-concurrently
 
 :turtle: Safe by default available
@@ -608,11 +612,16 @@ Then validate it in a separate migration. Once the check constraint is validated
 
 ```ruby
 class ValidateSomeColumnNotNull < ActiveRecord::Migration[7.2]
-  def change
+  def up
     validate_check_constraint :users, name: "users_some_column_null"
     change_column_null :users, :some_column, false
     remove_check_constraint :users, name: "users_some_column_null"
   end
+
+  def down
+    add_check_constraint :users, "some_column IS NOT NULL", name: "users_some_column_null", validate: false
+    change_column_null :users, :some_column, true
+  end
 end
 ```
 
@@ -723,7 +732,7 @@ Certain methods like `execute` and `change_table` cannot be inspected and are pr
 
 ## Safe by Default
 
-Make operations safe by default.
+Make certain operations safe by default. This allows you to write the code under the "Bad" section, but the migration will be performed as if you had written the "Good" version.
 
 - adding and removing an index
 - adding a foreign key
@@ -772,6 +781,16 @@ StrongMigrations.disable_check(:add_index)
 
 Check the [source code](https://github.com/ankane/strong_migrations/blob/master/lib/strong_migrations/error_messages.rb) for the list of keys.
 
+## Skip Databases
+
+Skip checks and other functionality for specific databases with:
+
+```ruby
+StrongMigrations.skip_database(:catalog)
+```
+
+Note: This does not affect `alphabetize_schema`.
+
 ## Down Migrations / Rollbacks
 
 By default, checks are disabled when migrating down. Enable them with:
@@ -853,7 +872,21 @@ 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]
+## Invalid Indexes
+
+In Postgres, adding an index non-concurrently can leave behind an invalid index if the lock timeout is reached. Running the migration again can result in an error.
+
+To automatically remove the invalid index when the migration runs again, use:
+
+```ruby
+StrongMigrations.remove_invalid_indexes = true
+```
+
+Note: This feature is experimental.
+
+## Lock Timeout Retries
+
+Note: This feature is experimental.
 
 There’s the option to automatically retry statements for migrations when the lock timeout is reached. Here’s how it works:
 

data/lib/strong_migrations/adapters/abstract_adapter.rb

@@ -13,11 +13,11 @@ module StrongMigrations
       end
 
       def set_statement_timeout(timeout)
-        raise StrongMigrations::Error, "Statement timeout not supported for this database"
+        # do nothing
       end
 
       def set_lock_timeout(timeout)
-        raise StrongMigrations::Error, "Lock timeout not supported for this database"
+        # do nothing
       end
 
       def check_lock_timeout(limit)

data/lib/strong_migrations/adapters/postgresql_adapter.rb

@@ -127,19 +127,19 @@ module StrongMigrations
         safe
       end
 
-      def constraints(table_name)
+      # TODO remove when Active Record < 7.1 is no longer supported
+      def index_invalid?(table_name, index_name)
         query = <<~SQL
           SELECT
-            conname AS name,
-            pg_get_constraintdef(oid) AS def
+            indisvalid
           FROM
-            pg_constraint
+            pg_index
           WHERE
-            contype = 'c' AND
-            convalidated AND
-            conrelid = #{connection.quote(connection.quote_table_name(table_name))}::regclass
+            indrelid = to_regclass(#{connection.quote(connection.quote_table_name(table_name))}) AND
+            indexrelid = to_regclass(#{connection.quote(connection.quote_table_name(index_name))}) AND
+            indisvalid = false
         SQL
-        select_all(query.squish).to_a
+        select_all(query.squish).any?
       end
 
       def writes_blocked?

data/lib/strong_migrations/checker.rb

@@ -11,10 +11,16 @@ module StrongMigrations
 
     def initialize(migration)
       @migration = migration
+      reset
+    end
+
+    def reset
       @new_tables = []
       @new_columns = []
       @timeouts_set = false
       @committed = false
+      @transaction_disabled = false
+      @skip_retries = false
     end
 
     def self.safety_assured
@@ -27,7 +33,10 @@ module StrongMigrations
       end
     end
 
-    def perform(method, *args)
+    def perform(method, *args, &block)
+      return yield if skip?
+
+      check_adapter
       check_version_supported
       set_timeouts
       check_lock_timeout
@@ -96,9 +105,9 @@ module StrongMigrations
           # TODO figure out how to handle methods that generate multiple statements
           # like add_reference(table, ref, index: {algorithm: :concurrently})
           # lock timeout after first statement will cause retry to fail
-          retry_lock_timeouts { yield }
+          retry_lock_timeouts { perform_method(method, *args, &block) }
         else
-          yield
+          perform_method(method, *args, &block)
         end
 
       # outdated statistics + a new index can hurt performance of existing queries
@@ -109,6 +118,13 @@ module StrongMigrations
       result
     end
 
+    def perform_method(method, *args)
+      if StrongMigrations.remove_invalid_indexes && direction == :up && method == :add_index && postgresql?
+        remove_invalid_index_if_needed(*args)
+      end
+      yield
+    end
+
     def retry_lock_timeouts(check_committed: false)
       retries = 0
       begin
@@ -129,8 +145,22 @@ module StrongMigrations
       version && version <= StrongMigrations.start_after
     end
 
+    def skip?
+      StrongMigrations.skipped_databases.map(&:to_s).include?(db_config_name)
+    end
+
     private
 
+    def check_adapter
+      return if defined?(@adapter_checked)
+
+      if adapter.instance_of?(Adapters::AbstractAdapter)
+        warn "[strong_migrations] Unsupported adapter: #{connection.adapter_name}. Use StrongMigrations.skip_database(#{db_config_name.to_sym.inspect}) to silence this warning."
+      end
+
+      @adapter_checked = true
+    end
+
     def check_version_supported
       return if defined?(@version_checked)
 
@@ -200,12 +230,48 @@ module StrongMigrations
       @migration.connection
     end
 
+    def db_config_name
+      connection.pool.db_config.name
+    end
+
     def retry_lock_timeouts?(method)
       (
         StrongMigrations.lock_timeout_retries > 0 &&
         !in_transaction? &&
-        method != :transaction
+        method != :transaction &&
+        !@skip_retries
       )
     end
+
+    def without_retries
+      previous_value = @skip_retries
+      begin
+        @skip_retries = true
+        yield
+      ensure
+        @skip_retries = previous_value
+      end
+    end
+
+    # REINDEX INDEX CONCURRENTLY leaves a new invalid index if it fails, so use remove_index instead
+    def remove_invalid_index_if_needed(*args)
+      options = args.extract_options!
+
+      # ensures has same options as existing index
+      # check args to avoid errors with index_exists?
+      return unless args.size == 2 && connection.index_exists?(*args, **options.merge(valid: false))
+
+      table, columns = args
+      index_name = options.fetch(:name, connection.index_name(table, columns))
+
+      # valid option is ignored for Active Record < 7.1, so check name as well
+      return if ar_version < 7.1 && !adapter.index_invalid?(table, index_name)
+
+      @migration.say("Attempting to remove invalid index")
+      without_retries do
+        # TODO pass index schema for extra safety?
+        @migration.remove_index(table, **{name: index_name}.merge(options.slice(:algorithm)))
+      end
+    end
   end
 end

data/lib/strong_migrations/checks.rb

@@ -10,7 +10,7 @@ module StrongMigrations
       if !new_table?(table)
         if postgresql? && options[:validate] != false
           add_options = options.merge(validate: false)
-          name = options[:name] || @migration.check_constraint_options(table, expression, options)[:name]
+          name = options[:name] || connection.check_constraint_options(table, expression, options)[:name]
           validate_options = {name: name}
 
           if StrongMigrations.safe_by_default
@@ -228,32 +228,30 @@ module StrongMigrations
       table, column, null, default = args
       if !null
         if postgresql?
-          safe = adapter.constraints(table).any? { |c| c["def"] == "CHECK ((#{column} IS NOT NULL))" || c["def"] == "CHECK ((#{connection.quote_column_name(column)} IS NOT NULL))" }
+          constraints = connection.check_constraints(table)
+          safe = constraints.any? { |c| c.options[:validate] && (c.expression == "#{column} IS NOT NULL" || c.expression == "#{connection.quote_column_name(column)} IS NOT NULL") }
 
           unless safe
             # match https://github.com/nullobject/rein
             constraint_name = "#{table}_#{column}_null"
 
-            add_code = constraint_str("ALTER TABLE %s ADD CONSTRAINT %s CHECK (%s IS NOT NULL) NOT VALID", [table, constraint_name, column])
-            validate_code = constraint_str("ALTER TABLE %s VALIDATE CONSTRAINT %s", [table, constraint_name])
-            remove_code = constraint_str("ALTER TABLE %s DROP CONSTRAINT %s", [table, constraint_name])
-
-            validate_constraint_code = String.new(command_str(:validate_check_constraint, [table, {name: constraint_name}]))
-
+            add_args = [table, "#{quote_column_if_needed(column)} IS NOT NULL", {name: constraint_name, validate: false}]
+            validate_args = [table, {name: constraint_name}]
             change_args = [table, column, null]
-
-            validate_constraint_code << "\n    #{command_str(:change_column_null, change_args)}"
-            validate_constraint_code << "\n    #{command_str(:remove_check_constraint, [table, {name: constraint_name}])}"
+            remove_args = [table, {name: constraint_name}]
 
             if StrongMigrations.safe_by_default
-              safe_change_column_null(add_code, validate_code, change_args, remove_code, default)
+              safe_change_column_null(add_args, validate_args, change_args, remove_args, default, constraints)
               throw :safe
             end
 
-            add_constraint_code = command_str(:add_check_constraint, [table, "#{quote_column_if_needed(column)} IS NOT NULL", {name: constraint_name, validate: false}])
+            add_constraint_code = command_str(:add_check_constraint, add_args)
 
+            up_code = String.new(command_str(:validate_check_constraint, validate_args))
+            up_code << "\n    #{command_str(:change_column_null, change_args)}"
+            up_code << "\n    #{command_str(:remove_check_constraint, remove_args)}"
             down_code = "#{add_constraint_code}\n    #{command_str(:change_column_null, [table, column, true])}"
-            validate_constraint_code = "def up\n    #{validate_constraint_code}\n  end\n\n  def down\n    #{down_code}\n  end"
+            validate_constraint_code = "def up\n    #{up_code}\n  end\n\n  def down\n    #{down_code}\n  end"
 
             raise_error :change_column_null_postgresql,
               add_constraint_code: add_constraint_code,
@@ -302,29 +300,28 @@ module StrongMigrations
       columns =
         case method
         when :remove_timestamps
-          ["created_at", "updated_at"]
+          [:created_at, :updated_at]
         when :remove_column
-          [args[1].to_s]
+          [args[1]]
         when :remove_columns
-          # Active Record 6.1+ supports options
           if args.last.is_a?(Hash)
-            args[1..-2].map(&:to_s)
+            args[1..-2]
           else
-            args[1..-1].map(&:to_s)
+            args[1..-1]
           end
         else
           options = args[2] || {}
           reference = args[1]
           cols = []
-          cols << "#{reference}_type" if options[:polymorphic]
-          cols << "#{reference}_id"
+          cols << "#{reference}_type".to_sym if options[:polymorphic]
+          cols << "#{reference}_id".to_sym
           cols
         end
 
-      code = "self.ignored_columns += #{columns.inspect}"
+      code = "self.ignored_columns += #{columns.map(&:to_s).inspect}"
 
       raise_error :remove_column,
-        model: args[0].to_s.classify,
+        model: model_name(args[0]),
         code: code,
         command: command_str(method, args),
         column_suffix: columns.size > 1 ? "s" : ""
@@ -392,7 +389,7 @@ module StrongMigrations
       message = message + append if append
 
       vars[:migration_name] = @migration.class.name
-      vars[:migration_suffix] = "[#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}]"
+      vars[:migration_suffix] = migration_suffix
       vars[:base_model] = "ApplicationRecord"
 
       # escape % not followed by {
@@ -433,7 +430,7 @@ module StrongMigrations
     end
 
     def backfill_code(table, column, default, function = false)
-      model = table.to_s.classify
+      model = model_name(table)
       if function
         # update_all(column: Arel.sql(default)) also works in newer versions of Active Record
         update_expr = "#{quote_column_if_needed(column)} = #{default}"
@@ -456,5 +453,13 @@ module StrongMigrations
     def new_column?(table, column)
       new_table?(table) || @new_columns.include?([table.to_s, column.to_s])
     end
+
+    def migration_suffix
+      "[#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}]"
+    end
+
+    def model_name(table)
+      table.to_s.classify
+    end
   end
 end

data/lib/strong_migrations/error_messages.rb

@@ -147,7 +147,7 @@ you're doing is safe before proceeding, then wrap it in a safety_assured { ... }
     create_table:
 "The force option will destroy existing tables.
 If this is intended, drop the existing table first.
-Otherwise, remove the force option.",
+In any case, remove the force option.",
 
     execute:
 "Strong Migrations does not support inspecting what happens inside an

data/lib/strong_migrations/migration.rb

@@ -18,7 +18,8 @@ module StrongMigrations
         end
       end
     end
-    ruby2_keywords(:method_missing) if respond_to?(:ruby2_keywords, true)
+    # same as ActiveRecord::Migration
+    ruby2_keywords(:method_missing)
 
     def revert(*)
       if strong_migrations_checker.version_safe?

data/lib/strong_migrations/{database_tasks.rb → migration_context.rb}

@@ -1,8 +1,26 @@
 module StrongMigrations
-  module DatabaseTasks
-    def migrate(...)
+  module MigrationContext
+    def up(...)
       super
     rescue => e
+      strong_migrations_process_exception(e)
+    end
+
+    def down(...)
+      super
+    rescue => e
+      strong_migrations_process_exception(e)
+    end
+
+    def run(...)
+      super
+    rescue => e
+      strong_migrations_process_exception(e)
+    end
+
+    private
+
+    def strong_migrations_process_exception(e)
       if e.cause.is_a?(StrongMigrations::Error)
         # strip cause and clean backtrace
         def e.cause

data/lib/strong_migrations/migrator.rb

@@ -6,11 +6,13 @@ module StrongMigrations
       # handle MigrationProxy class
       migration = migration.send(:migration) if migration.respond_to?(:migration, true)
 
-      # retry migration since the entire transaction needs to be rerun
       checker = migration.send(:strong_migrations_checker)
+      return super if checker.skip?
+
+      # retry migration since the entire transaction needs to be rerun
       checker.retry_lock_timeouts(check_committed: true) do
         # failed transaction reverts timeout, so need to re-apply
-        checker.timeouts_set = false
+        checker.reset
 
         super(migration, ...)
       end

data/lib/strong_migrations/safe_methods.rb

@@ -4,7 +4,6 @@ module StrongMigrations
       StrongMigrations.safe_by_default && [:add_index, :add_belongs_to, :add_reference, :remove_index, :add_foreign_key, :add_check_constraint, :change_column_null].include?(method)
     end
 
-    # TODO check if invalid index with expected name exists and remove if needed
     def safe_add_index(*args, **options)
       disable_transaction
       @migration.add_index(*args, **options.merge(algorithm: :concurrently))
@@ -47,14 +46,16 @@ module StrongMigrations
     def safe_add_foreign_key(from_table, to_table, *args, **options)
       @migration.reversible do |dir|
         dir.up do
-          @migration.add_foreign_key(from_table, to_table, *args, **options.merge(validate: false))
+          # validate option is unintentionally ignored for Active Record < 7.1
+          # https://github.com/rails/rails/pull/45896
+          if !connection.foreign_key_exists?(from_table, to_table, **options.merge(validate: false))
+            @migration.add_foreign_key(from_table, to_table, *args, **options.merge(validate: false))
+          end
           disable_transaction
-          validate_options = options.slice(:column, :name)
-          @migration.validate_foreign_key(from_table, to_table, **validate_options)
+          @migration.validate_foreign_key(from_table, to_table, **options.slice(:column, :name))
         end
         dir.down do
-          remove_options = options.slice(:column, :name)
-          @migration.remove_foreign_key(from_table, to_table, **remove_options)
+          @migration.remove_foreign_key(from_table, to_table, **options.slice(:column, :name))
         end
       end
     end
@@ -62,7 +63,10 @@ module StrongMigrations
     def safe_add_check_constraint(table, expression, *args, add_options, validate_options)
       @migration.reversible do |dir|
         dir.up do
-          @migration.add_check_constraint(table, expression, *args, **add_options)
+          # only skip invalid constraints
+          unless connection.check_constraints(table).any? { |c| c.options[:name] == validate_options[:name] && !c.options[:validate] }
+            @migration.add_check_constraint(table, expression, *args, **add_options)
+          end
           disable_transaction
           @migration.validate_check_constraint(table, **validate_options)
         end
@@ -72,35 +76,33 @@ module StrongMigrations
       end
     end
 
-    def safe_change_column_null(add_code, validate_code, change_args, remove_code, default)
+    def safe_change_column_null(add_args, validate_args, change_args, remove_args, default, constraints)
       @migration.reversible do |dir|
         dir.up do
           unless default.nil?
             raise Error, "default value not supported yet with safe_by_default"
           end
 
-          @migration.safety_assured do
-            @migration.execute(add_code)
-            disable_transaction
-            @migration.execute(validate_code)
-          end
-          if change_args
-            @migration.change_column_null(*change_args)
-            @migration.safety_assured do
-              @migration.execute(remove_code)
-            end
+          add_options = add_args.extract_options!
+          validate_options = validate_args.extract_options!
+          remove_options = remove_args.extract_options!
+
+          # only skip invalid constraints
+          unless constraints.any? { |c| c.options[:name] == validate_options[:name] && !c.options[:validate] }
+            @migration.add_check_constraint(*add_args, **add_options)
           end
+          disable_transaction
+
+          connection.begin_db_transaction
+          @migration.validate_check_constraint(*validate_args, **validate_options)
+          @migration.change_column_null(*change_args)
+          @migration.remove_check_constraint(*remove_args, **remove_options)
+          connection.commit_db_transaction
         end
         dir.down do
-          if change_args
-            down_args = change_args.dup
-            down_args[2] = true
-            @migration.change_column_null(*down_args)
-          else
-            @migration.safety_assured do
-              @migration.execute(remove_code)
-            end
-          end
+          down_args = change_args.dup
+          down_args[2] = true
+          @migration.change_column_null(*down_args)
         end
       end
     end
@@ -109,13 +111,13 @@ module StrongMigrations
     # so just commit at start
     def disable_transaction
       if in_transaction? && !transaction_disabled
-        @migration.connection.commit_db_transaction
+        connection.commit_db_transaction
         self.transaction_disabled = true
       end
     end
 
     def in_transaction?
-      @migration.connection.open_transactions > 0
+      connection.open_transactions > 0
     end
   end
 end

data/lib/strong_migrations/version.rb

@@ -1,3 +1,3 @@
 module StrongMigrations
-  VERSION = "2.0.2"
+  VERSION = "2.1.0"
 end

data/lib/strong_migrations.rb

@@ -11,8 +11,8 @@ require_relative "strong_migrations/adapters/postgresql_adapter"
 require_relative "strong_migrations/checks"
 require_relative "strong_migrations/safe_methods"
 require_relative "strong_migrations/checker"
-require_relative "strong_migrations/database_tasks"
 require_relative "strong_migrations/migration"
+require_relative "strong_migrations/migration_context"
 require_relative "strong_migrations/migrator"
 require_relative "strong_migrations/version"
 
@@ -29,7 +29,7 @@ module StrongMigrations
       :target_postgresql_version, :target_mysql_version, :target_mariadb_version,
       :enabled_checks, :lock_timeout, :statement_timeout, :check_down, :target_version,
       :safe_by_default, :target_sql_mode, :lock_timeout_retries, :lock_timeout_retry_delay,
-      :alphabetize_schema
+      :alphabetize_schema, :skipped_databases, :remove_invalid_indexes
     attr_writer :lock_timeout_limit
   end
   self.auto_analyze = false
@@ -40,6 +40,8 @@ module StrongMigrations
   self.safe_by_default = false
   self.check_down = false
   self.alphabetize_schema = false
+  self.skipped_databases = []
+  self.remove_invalid_indexes = false
 
   # private
   def self.developer_env?
@@ -83,6 +85,10 @@ module StrongMigrations
       false
     end
   end
+
+  def self.skip_database(database)
+    self.skipped_databases << database
+  end
 end
 
 # load error messages
@@ -90,12 +96,9 @@ require_relative "strong_migrations/error_messages"
 
 ActiveSupport.on_load(:active_record) do
   ActiveRecord::Migration.prepend(StrongMigrations::Migration)
+  ActiveRecord::MigrationContext.prepend(StrongMigrations::MigrationContext)
   ActiveRecord::Migrator.prepend(StrongMigrations::Migrator)
 
-  if defined?(ActiveRecord::Tasks::DatabaseTasks)
-    ActiveRecord::Tasks::DatabaseTasks.singleton_class.prepend(StrongMigrations::DatabaseTasks)
-  end
-
   require_relative "strong_migrations/schema_dumper"
   ActiveRecord::SchemaDumper.prepend(StrongMigrations::SchemaDumper)
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: strong_migrations
 version: !ruby/object:Gem::Version
-  version: 2.0.2
+  version: 2.1.0
 platform: ruby
 authors:
 - Andrew Kane
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-10-30 00:00:00.000000000 Z
+date: 2024-11-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -47,9 +47,9 @@ files:
 - lib/strong_migrations/adapters/postgresql_adapter.rb
 - lib/strong_migrations/checker.rb
 - lib/strong_migrations/checks.rb
-- lib/strong_migrations/database_tasks.rb
 - lib/strong_migrations/error_messages.rb
 - lib/strong_migrations/migration.rb
+- lib/strong_migrations/migration_context.rb
 - lib/strong_migrations/migrator.rb
 - lib/strong_migrations/railtie.rb
 - lib/strong_migrations/safe_methods.rb
@@ -75,7 +75,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.16
+rubygems_version: 3.5.22
 signing_key:
 specification_version: 4
 summary: Catch unsafe migrations in development