strong_migrations 0.6.8 → 1.6.1

data/lib/strong_migrations/error_messages.rb

@@ -0,0 +1,250 @@
+module StrongMigrations
+  self.error_messages = {
+    add_column_default:
+"Adding a column with a %{default_type} default blocks %{rewrite_blocks} while the entire table is rewritten.
+Instead, add the column without a default value, then change the default.
+
+class %{migration_name} < ActiveRecord::Migration%{migration_suffix}
+  def up
+    %{add_command}
+    %{change_command}
+  end
+
+  def down
+    %{remove_command}
+  end
+end
+
+Then backfill the existing rows in the Rails console or a separate migration with disable_ddl_transaction!.
+
+class Backfill%{migration_name} < ActiveRecord::Migration%{migration_suffix}
+  disable_ddl_transaction!
+
+  def up
+    %{code}
+  end
+end",
+
+    add_column_default_null:
+"Adding a column with a null default blocks %{rewrite_blocks} while the entire table is rewritten.
+Instead, add the column without a default value.
+
+class %{migration_name} < ActiveRecord::Migration%{migration_suffix}
+  def change
+    %{command}
+  end
+end",
+
+    add_column_default_callable:
+"Strong Migrations does not support inspecting callable default values.
+Please make really sure you're not calling a VOLATILE function,
+then wrap it in a safety_assured { ... } block.",
+
+    add_column_json:
+"There's no equality operator for the json column type, which can cause errors for
+existing SELECT DISTINCT queries in your application. Use jsonb instead.
+
+class %{migration_name} < ActiveRecord::Migration%{migration_suffix}
+  def change
+    %{command}
+  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:
+
+1. Create a new column
+2. Write to both columns
+3. Backfill data from the old column to the new column
+4. Move reads from the old column to the new column
+5. Stop writing to the old column
+6. Drop the old column",
+
+    change_column_with_not_null:
+"Changing the type is safe, but setting NOT NULL is not.",
+
+    remove_column: "Active Record caches attributes, which causes problems
+when removing columns. Be sure to ignore the column%{column_suffix}:
+
+class %{model} < %{base_model}
+  %{code}
+end
+
+Deploy the code, then wrap this step in a safety_assured { ... } block.
+
+class %{migration_name} < ActiveRecord::Migration%{migration_suffix}
+  def change
+    safety_assured { %{command} }
+  end
+end",
+
+    rename_column:
+"Renaming a column that's in use will cause errors
+in your application. A safer approach is to:
+
+1. Create a new column
+2. Write to both columns
+3. Backfill data from the old column to new column
+4. Move reads from the old column to the new column
+5. Stop writing to the old column
+6. Drop the old column",
+
+    rename_table:
+"Renaming a table that's in use will cause errors
+in your application. A safer approach is to:
+
+1. Create a new table. Don't forget to recreate indexes from the old table
+2. Write to both tables
+3. Backfill data from the old table to new table
+4. Move reads from the old table to the new table
+5. Stop writing to the old table
+6. Drop the old table",
+
+    add_reference:
+"%{headline} Instead, use:
+
+class %{migration_name} < ActiveRecord::Migration%{migration_suffix}
+  disable_ddl_transaction!
+
+  def change
+    %{command}
+  end
+end",
+
+    add_index:
+"Adding an index non-concurrently blocks writes. Instead, use:
+
+class %{migration_name} < ActiveRecord::Migration%{migration_suffix}
+  disable_ddl_transaction!
+
+  def change
+    %{command}
+  end
+end",
+
+    remove_index:
+"Removing an index non-concurrently blocks writes. Instead, use:
+
+class %{migration_name} < ActiveRecord::Migration%{migration_suffix}
+  disable_ddl_transaction!
+
+  def change
+    %{command}
+  end
+end",
+
+    add_index_columns:
+"Adding a non-unique index with more than three columns rarely improves performance.
+Instead, start an index with columns that narrow down the results the most.",
+
+    add_index_corruption:
+"Adding an index concurrently can cause silent data corruption in Postgres 14.0 to 14.3.
+Upgrade Postgres before adding new indexes, or wrap this step in a safety_assured { ... } block
+to accept the risk.",
+
+    change_table:
+"Strong Migrations does not support inspecting what happens inside a
+change_table block, 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.",
+
+    create_table:
+"The force option will destroy existing tables.
+If this is intended, drop the existing table first.
+Otherwise, remove the force option.",
+
+    execute:
+"Strong Migrations does not support inspecting what happens inside an
+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
+Rails console or a separate migration with disable_ddl_transaction!.
+
+class Backfill%{migration_name} < ActiveRecord::Migration%{migration_suffix}
+  disable_ddl_transaction!
+
+  def up
+    %{code}
+  end
+end",
+
+    change_column_null_postgresql:
+"Setting NOT NULL on an existing column blocks reads and writes while every row is checked.
+Instead, add a check constraint and validate it in a separate migration.
+
+class %{migration_name} < ActiveRecord::Migration%{migration_suffix}
+  def change
+    %{add_constraint_code}
+  end
+end
+
+class Validate%{migration_name} < ActiveRecord::Migration%{migration_suffix}
+  %{validate_constraint_code}
+end",
+
+    change_column_null_mysql:
+"Setting NOT NULL on an existing column is not safe without strict mode enabled.",
+
+    add_foreign_key:
+"Adding a foreign key blocks writes on both tables. Instead,
+add the foreign key without validating existing rows,
+then validate them in a separate migration.
+
+class %{migration_name} < ActiveRecord::Migration%{migration_suffix}
+  def change
+    %{add_foreign_key_code}
+  end
+end
+
+class Validate%{migration_name} < ActiveRecord::Migration%{migration_suffix}
+  def change
+    %{validate_foreign_key_code}
+  end
+end",
+
+    validate_foreign_key:
+"Validating a foreign key while writes are blocked is dangerous.
+Use disable_ddl_transaction! or a separate migration.",
+
+    add_check_constraint:
+"Adding a check constraint key blocks reads and writes while every row is checked.
+Instead, add the check constraint without validating existing rows,
+then validate them in a separate migration.
+
+class %{migration_name} < ActiveRecord::Migration%{migration_suffix}
+  def change
+    %{add_check_constraint_code}
+  end
+end
+
+class Validate%{migration_name} < ActiveRecord::Migration%{migration_suffix}
+  def change
+    %{validate_check_constraint_code}
+  end
+end",
+
+    add_check_constraint_mysql:
+"Adding a check constraint to an existing table is not safe with your database engine.",
+
+    validate_check_constraint:
+"Validating a check constraint while writes are blocked is dangerous.
+Use disable_ddl_transaction! or a separate migration.",
+
+    add_exclusion_constraint:
+"Adding an exclusion constraint blocks reads and writes while every row is checked."
+  }
+  self.enabled_checks = (error_messages.keys - [:remove_index]).map { |k| [k, {}] }.to_h
+end

data/lib/strong_migrations/migration.rb

@@ -3,11 +3,19 @@ module StrongMigrations
     def migrate(direction)
       strong_migrations_checker.direction = direction
       super
+      connection.begin_db_transaction if strong_migrations_checker.transaction_disabled
     end
 
     def method_missing(method, *args)
-      strong_migrations_checker.perform(method, *args) do
-        super
+      return super if is_a?(ActiveRecord::Schema)
+
+      # Active Record 7.0.2+ versioned schema
+      return super if defined?(ActiveRecord::Schema::Definition) && is_a?(ActiveRecord::Schema::Definition)
+
+      catch(:safe) do
+        strong_migrations_checker.perform(method, *args) do
+          super
+        end
       end
     end
     ruby2_keywords(:method_missing) if respond_to?(:ruby2_keywords, true)

data/lib/strong_migrations/migrator.rb

@@ -0,0 +1,19 @@
+module StrongMigrations
+  module Migrator
+    def ddl_transaction(migration, *args)
+      return super unless StrongMigrations.lock_timeout_retries > 0 && use_transaction?(migration)
+
+      # 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)
+      checker.retry_lock_timeouts(check_committed: true) do
+        # failed transaction reverts timeout, so need to re-apply
+        checker.timeouts_set = false
+
+        super(migration, *args)
+      end
+    end
+  end
+end

data/lib/strong_migrations/railtie.rb

@@ -5,10 +5,6 @@ module StrongMigrations
   class Railtie < Rails::Railtie
     rake_tasks do
       load "tasks/strong_migrations.rake"
-
-      ["db:drop", "db:reset", "db:schema:load", "db:structure:load"].each do |t|
-        Rake::Task[t].enhance ["strong_migrations:safety_assured"]
-      end
     end
   end
 end

data/lib/strong_migrations/safe_methods.rb

@@ -0,0 +1,128 @@
+module StrongMigrations
+  module SafeMethods
+    def safe_by_default_method?(method)
+      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))
+    end
+
+    def safe_remove_index(*args, **options)
+      disable_transaction
+      @migration.remove_index(*args, **options.merge(algorithm: :concurrently))
+    end
+
+    def safe_add_reference(table, reference, *args, **options)
+      @migration.reversible do |dir|
+        dir.up do
+          disable_transaction
+          foreign_key = options.delete(:foreign_key)
+          @migration.add_reference(table, reference, *args, **options)
+          if foreign_key
+            # same as Active Record
+            name =
+              if foreign_key.is_a?(Hash) && foreign_key[:to_table]
+                foreign_key[:to_table]
+              else
+                (ActiveRecord::Base.pluralize_table_names ? reference.to_s.pluralize : reference).to_sym
+              end
+
+            if reference
+              @migration.add_foreign_key(table, name, column: "#{reference}_id")
+            else
+              @migration.add_foreign_key(table, name)
+            end
+          end
+        end
+        dir.down do
+          @migration.remove_reference(table, reference)
+        end
+      end
+    end
+
+    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))
+          disable_transaction
+          validate_options = options.slice(:column, :name)
+          if ActiveRecord::VERSION::MAJOR >= 6
+            @migration.validate_foreign_key(from_table, to_table, **validate_options)
+          else
+            @migration.validate_foreign_key(from_table, validate_options.any? ? validate_options : to_table)
+          end
+        end
+        dir.down do
+          remove_options = options.slice(:column, :name)
+          if ActiveRecord::VERSION::MAJOR >= 6
+            @migration.remove_foreign_key(from_table, to_table, **remove_options)
+          else
+            @migration.remove_foreign_key(from_table, remove_options.any? ? remove_options : to_table)
+          end
+        end
+      end
+    end
+
+    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)
+          disable_transaction
+          @migration.validate_check_constraint(table, **validate_options)
+        end
+        dir.down do
+          @migration.remove_check_constraint(table, expression, **add_options.except(:validate))
+        end
+      end
+    end
+
+    def safe_change_column_null(add_code, validate_code, change_args, remove_code, default)
+      @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
+          end
+        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
+        end
+      end
+    end
+
+    # hard to commit at right time when reverting
+    # so just commit at start
+    def disable_transaction
+      if in_transaction? && !transaction_disabled
+        @migration.connection.commit_db_transaction
+        self.transaction_disabled = true
+      end
+    end
+
+    def in_transaction?
+      @migration.connection.open_transactions > 0
+    end
+  end
+end

data/lib/strong_migrations/schema_dumper.rb

@@ -0,0 +1,21 @@
+module StrongMigrations
+  module SchemaDumper
+    def initialize(connection, *args, **options)
+      return super unless StrongMigrations.alphabetize_schema
+
+      super(WrappedConnection.new(connection), *args, **options)
+    end
+  end
+
+  class WrappedConnection
+    delegate_missing_to :@connection
+
+    def initialize(connection)
+      @connection = connection
+    end
+
+    def columns(*args, **options)
+      @connection.columns(*args, **options).sort_by(&:name)
+    end
+  end
+end

data/lib/strong_migrations/version.rb

@@ -1,3 +1,3 @@
 module StrongMigrations
-  VERSION = "0.6.8"
+  VERSION = "1.6.1"
 end