dynamic_migrations 3.1.0 → 3.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f112c797c02407f6c2b090fcd5dabd05861a864069f6aba51a96467be7a093f2
-  data.tar.gz: 78bb49e74e722db75f9a6366d6034b947632a41326241f24e51ea6eba4879720
+  metadata.gz: '05957cccec4b1ee5138e9e74daa7714da41b99be958f7171e1c88475fe495e7b'
+  data.tar.gz: fd7cb71f07ded6599286dac27c274832bf97de43e56b69a47b7238aefaac2cde
 SHA512:
-  metadata.gz: 9ed20eadb8e64389d12665938cff6702d19c2ec5d8c8e9a8b52cc0a7cf715c76596eb9a868ae0411c3f417e39425708a96ee8b890ea40b4f6403ce67dc5daa92
-  data.tar.gz: 49aa26f15e57e2d4f18c5dc850e35946781881b63fe52182eb7d707605b9615f4c1d9c6ac1c4807782577646712207032d0a775614a4552ad6fbef7d83d68157
+  metadata.gz: f1729685ce54c91e0a3a8ce03fbb552887450b843f4c654678717aba41c1e52b66dff1104b9acaedd955e221267619e64405fe4088af9de54b9216446bf87984
+  data.tar.gz: 95668080a1d329fcaf0172e3593cfc59bab34b7edca05fedfe23d10d7b83945bd9c79943768765f505997fdd8781721569b2845d752d8f99450d251758d41eac

data/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [3.2.0](https://github.com/craigulliott/dynamic_migrations/compare/v3.1.1...v3.2.0) (2023-08-16)
+
+
+### Features
+
+* adding a with_connection method to the database which yields to a block, and provides a connection object to that block ([fc1590a](https://github.com/craigulliott/dynamic_migrations/commit/fc1590a00be8d3f9f0ee0472a96be94b80e667e0))
+
+## [3.1.1](https://github.com/craigulliott/dynamic_migrations/compare/v3.1.0...v3.1.1) (2023-08-16)
+
+
+### Bug Fixes
+
+* refactoring the migration generator so that it handles dependencies between migrations ([8d0f8d8](https://github.com/craigulliott/dynamic_migrations/commit/8d0f8d8cd4a22b974b6449c62ad2a2d74aeffb2e))
+
 ## [3.1.0](https://github.com/craigulliott/dynamic_migrations/compare/v3.0.0...v3.1.0) (2023-08-14)
 
 

data/lib/dynamic_migrations/postgres/generator/column.rb

@@ -28,11 +28,16 @@ module DynamicMigrations
             data_type = "\"#{data_type}\""
           end
 
-          add_migration column.table.schema.name, column.table.name, :add_column, column.name, code_comment, <<~RUBY
-            add_column :#{column.table.name}, :#{column.name}, :#{data_type}, #{options_syntax}, comment: <<~COMMENT
-              #{indent column.description}
-            COMMENT
-          RUBY
+          add_fragment schema: column.table.schema,
+            table: column.table,
+            migration_method: :add_column,
+            object: column,
+            code_comment: code_comment,
+            migration: <<~RUBY
+              add_column :#{column.table.name}, :#{column.name}, :#{data_type}, #{options_syntax}, comment: <<~COMMENT
+                #{indent column.description}
+              COMMENT
+            RUBY
         end
 
         def change_column column, code_comment = nil
@@ -54,15 +59,25 @@ module DynamicMigrations
             data_type = ":\"#{data_type}\""
           end
 
-          add_migration column.table.schema.name, column.table.name, :change_column, column.name, code_comment, <<~RUBY
-            change_column :#{column.table.name}, :#{column.name}, :#{data_type}, #{options_syntax}
-          RUBY
+          add_fragment schema: column.table.schema,
+            table: column.table,
+            migration_method: :change_column,
+            object: column,
+            code_comment: code_comment,
+            migration: <<~RUBY
+              change_column :#{column.table.name}, :#{column.name}, :#{data_type}, #{options_syntax}
+            RUBY
         end
 
         def remove_column column, code_comment = nil
-          add_migration column.table.schema.name, column.table.name, :remove_column, column.name, code_comment, <<~RUBY
-            remove_column :#{column.table.name}, :#{column.name}
-          RUBY
+          add_fragment schema: column.table.schema,
+            table: column.table,
+            migration_method: :remove_column,
+            object: column,
+            code_comment: code_comment,
+            migration: <<~RUBY
+              remove_column :#{column.table.name}, :#{column.name}
+            RUBY
         end
 
         # add a comment to a column
@@ -73,18 +88,28 @@ module DynamicMigrations
             raise MissingDescriptionError
           end
 
-          add_migration column.table.schema.name, column.table.name, :set_column_comment, column.name, code_comment, <<~RUBY
-            set_column_comment :#{column.table.name}, :#{column.name}, <<~COMMENT
-              #{indent description}
-            COMMENT
-          RUBY
+          add_fragment schema: column.table.schema,
+            table: column.table,
+            migration_method: :set_column_comment,
+            object: column,
+            code_comment: code_comment,
+            migration: <<~RUBY
+              set_column_comment :#{column.table.name}, :#{column.name}, <<~COMMENT
+                #{indent description}
+              COMMENT
+            RUBY
         end
 
         # remove the comment from a column
         def remove_column_comment column, code_comment = nil
-          add_migration column.table.schema.name, column.table.name, :remove_column_comment, column.name, code_comment, <<~RUBY
-            remove_column_comment :#{column.table.name}, :#{column.name}
-          RUBY
+          add_fragment schema: column.table.schema,
+            table: column.table,
+            migration_method: :remove_column_comment,
+            object: column,
+            code_comment: code_comment,
+            migration: <<~RUBY
+              remove_column_comment :#{column.table.name}, :#{column.name}
+            RUBY
         end
       end
     end

data/lib/dynamic_migrations/postgres/generator/foreign_key_constraint.rb

@@ -29,15 +29,26 @@ module DynamicMigrations
 
           options_syntax = options.map { |k, v| "#{k}: #{v}" }.join(", ")
 
-          add_migration foreign_key_constraint.table.schema.name, foreign_key_constraint.table.name, :add_foreign_key, foreign_key_constraint.name, code_comment, <<~RUBY
-            add_foreign_key :#{foreign_key_constraint.table.name}, #{column_names}, :#{foreign_key_constraint.foreign_table.name}, #{foreign_column_names}, #{options_syntax}
-          RUBY
+          add_fragment schema: foreign_key_constraint.table.schema,
+            table: foreign_key_constraint.table,
+            migration_method: :add_foreign_key,
+            object: foreign_key_constraint,
+            code_comment: code_comment,
+            dependent_table: foreign_key_constraint.foreign_table,
+            migration: <<~RUBY
+              add_foreign_key :#{foreign_key_constraint.table.name}, #{column_names}, :#{foreign_key_constraint.foreign_table.name}, #{foreign_column_names}, #{options_syntax}
+            RUBY
         end
 
         def remove_foreign_key_constraint foreign_key_constraint, code_comment = nil
-          add_migration foreign_key_constraint.table.schema.name, foreign_key_constraint.table.name, :remove_foreign_key, foreign_key_constraint.name, code_comment, <<~RUBY
-            remove_foreign_key :#{foreign_key_constraint.table.name}, :#{foreign_key_constraint.name}
-          RUBY
+          add_fragment schema: foreign_key_constraint.table.schema,
+            table: foreign_key_constraint.table,
+            migration_method: :remove_foreign_key,
+            object: foreign_key_constraint,
+            code_comment: code_comment,
+            migration: <<~RUBY
+              remove_foreign_key :#{foreign_key_constraint.table.name}, :#{foreign_key_constraint.name}
+            RUBY
         end
 
         def recreate_foreign_key_constraint original_foreign_key_constraint, updated_foreign_key_constraint
@@ -65,18 +76,28 @@ module DynamicMigrations
             raise MissingDescriptionError
           end
 
-          add_migration foreign_key_constraint.table.schema.name, foreign_key_constraint.table.name, :set_foreign_key_constraint_comment, foreign_key_constraint.name, code_comment, <<~RUBY
-            set_foreign_key_comment :#{foreign_key_constraint.table.name}, :#{foreign_key_constraint.name}, <<~COMMENT
-              #{indent description}
-            COMMENT
-          RUBY
+          add_fragment schema: foreign_key_constraint.table.schema,
+            table: foreign_key_constraint.table,
+            migration_method: :set_foreign_key_constraint_comment,
+            object: foreign_key_constraint,
+            code_comment: code_comment,
+            migration: <<~RUBY
+              set_foreign_key_comment :#{foreign_key_constraint.table.name}, :#{foreign_key_constraint.name}, <<~COMMENT
+                #{indent description}
+              COMMENT
+            RUBY
         end
 
         # remove the comment from a foreign_key_constraint
         def remove_foreign_key_constraint_comment foreign_key_constraint, code_comment = nil
-          add_migration foreign_key_constraint.table.schema.name, foreign_key_constraint.table.name, :remove_foreign_key_constraint_comment, foreign_key_constraint.name, code_comment, <<~RUBY
-            remove_foreign_key_comment :#{foreign_key_constraint.table.name}, :#{foreign_key_constraint.name}
-          RUBY
+          add_fragment schema: foreign_key_constraint.table.schema,
+            table: foreign_key_constraint.table,
+            migration_method: :remove_foreign_key_constraint_comment,
+            object: foreign_key_constraint,
+            code_comment: code_comment,
+            migration: <<~RUBY
+              remove_foreign_key_comment :#{foreign_key_constraint.table.name}, :#{foreign_key_constraint.name}
+            RUBY
         end
       end
     end

data/lib/dynamic_migrations/postgres/generator/fragment.rb

@@ -2,15 +2,25 @@ module DynamicMigrations
   module Postgres
     class Generator
       class Fragment
+        attr_reader :schema_name
+        attr_reader :table_name
+        attr_reader :migration_method
         attr_reader :object_name
-        attr_reader :code_comment
+        attr_reader :dependency_schema_name
+        attr_reader :dependency_table_name
 
-        def initialize object_name, code_comment, content
+        def initialize schema_name, table_name, migration_method, object_name, code_comment, content
+          @schema_name = schema_name
+          @table_name = table_name
+          @migration_method = migration_method
           @object_name = object_name
           @code_comment = code_comment
           @content = content
         end
 
+        # Returns a string representation of the fragment for use in the final
+        # migration. This final string is a combination of the code_comment (if present)
+        # and the content of the fragment.
         def to_s
           strings = []
           comment = @code_comment
@@ -21,9 +31,34 @@ module DynamicMigrations
           strings.join("\n").strip
         end
 
+        # Returns true if the fragment has a code comment, otherwise false.
         def has_code_comment?
           !@code_comment.nil?
         end
+
+        # If a table dependency has been set, then returns a hash with the schema_name
+        # and table_name, otherwise returns nil.
+        def dependency
+          if dependency_schema_name && dependency_table_name
+            {
+              schema_name: dependency_schema_name,
+              table_name: dependency_table_name
+            }
+          end
+        end
+
+        # returns true if the fragment has a table dependency, and the dependency matches
+        # the provided schema_name and table_name, otherwise returns false.
+        def is_dependent_on? schema_name, table_name
+          dependency_schema_name && schema_name == dependency_schema_name && table_name == dependency_table_name || false
+        end
+
+        # Set the table table dependency for this fragment. Takes a schema name and
+        # table name
+        def set_dependent_table schema_name, table_name
+          @dependency_schema_name = schema_name
+          @dependency_table_name = table_name
+        end
       end
     end
   end

data/lib/dynamic_migrations/postgres/generator/function.rb

@@ -25,13 +25,18 @@ module DynamicMigrations
             fn_sql << ";"
           end
 
-          add_migration function.schema.name, function.triggers.first&.table&.name, :create_function, function.name, code_comment, (comment_sql + <<~RUBY)
-            create_function :#{function.name}#{optional_options_syntax} do
-              <<~SQL
-                #{indent fn_sql}
-              SQL
-            end
-          RUBY
+          add_fragment schema: function.schema,
+            table: function.triggers.first&.table,
+            migration_method: :create_function,
+            object: function,
+            code_comment: code_comment,
+            migration: comment_sql + <<~RUBY
+              create_function :#{function.name}#{optional_options_syntax} do
+                <<~SQL
+                  #{indent fn_sql}
+                SQL
+              end
+            RUBY
         end
 
         def update_function function, code_comment = nil
@@ -41,35 +46,55 @@ module DynamicMigrations
             fn_sql << ";"
           end
 
-          add_migration function.schema.name, function.triggers.first&.table&.name, :update_function, function.name, code_comment, <<~RUBY
-            update_function :#{function.name} do
-              <<~SQL
-                #{indent fn_sql}
-              SQL
-            end
-          RUBY
+          add_fragment schema: function.schema,
+            table: function.triggers.first&.table,
+            migration_method: :update_function,
+            object: function,
+            code_comment: code_comment,
+            migration: <<~RUBY
+              update_function :#{function.name} do
+                <<~SQL
+                  #{indent fn_sql}
+                SQL
+              end
+            RUBY
         end
 
         def drop_function function, code_comment = nil
-          add_migration function.schema.name, function.triggers.first&.table&.name, :drop_function, function.name, code_comment, <<~RUBY
-            drop_function :#{function.name}
-          RUBY
+          add_fragment schema: function.schema,
+            table: function.triggers.first&.table,
+            migration_method: :drop_function,
+            object: function,
+            code_comment: code_comment,
+            migration: <<~RUBY
+              drop_function :#{function.name}
+            RUBY
         end
 
         # add a comment to a function
         def set_function_comment function, code_comment = nil
-          add_migration function.schema.name, function.triggers.first&.table&.name, :set_function_comment, function.name, code_comment, <<~RUBY
-            set_function_comment :#{function.name}, <<~COMMENT
-              #{indent function.description || ""}
-            COMMENT
-          RUBY
+          add_fragment schema: function.schema,
+            table: function.triggers.first&.table,
+            migration_method: :set_function_comment,
+            object: function,
+            code_comment: code_comment,
+            migration: <<~RUBY
+              set_function_comment :#{function.name}, <<~COMMENT
+                #{indent function.description || ""}
+              COMMENT
+            RUBY
         end
 
         # remove the comment from a function
         def remove_function_comment function, code_comment = nil
-          add_migration function.schema.name, function.triggers.first&.table&.name, :remove_function_comment, function.name, code_comment, <<~RUBY
-            remove_function_comment :#{function.name}
-          RUBY
+          add_fragment schema: function.schema,
+            table: function.triggers.first&.table,
+            migration_method: :remove_function_comment,
+            object: function,
+            code_comment: code_comment,
+            migration: <<~RUBY
+              remove_function_comment :#{function.name}
+            RUBY
         end
       end
     end

data/lib/dynamic_migrations/postgres/generator/index.rb

@@ -46,15 +46,25 @@ module DynamicMigrations
 
           options_syntax = options.map { |k, v| "#{k}: #{v}" }.join(", ")
 
-          add_migration index.table.schema.name, index.table.name, :add_index, index.name, code_comment, (where_sql + <<~RUBY)
-            add_index :#{index.table.name}, #{column_names}, #{options_syntax}
-          RUBY
+          add_fragment schema: index.table.schema,
+            table: index.table,
+            migration_method: :add_index,
+            object: index,
+            code_comment: code_comment,
+            migration: where_sql + <<~RUBY
+              add_index :#{index.table.name}, #{column_names}, #{options_syntax}
+            RUBY
         end
 
         def remove_index index, code_comment = nil
-          add_migration index.table.schema.name, index.table.name, :remove_index, index.name, code_comment, <<~RUBY
-            remove_index :#{index.table.name}, :#{index.name}
-          RUBY
+          add_fragment schema: index.table.schema,
+            table: index.table,
+            migration_method: :remove_index,
+            object: index,
+            code_comment: code_comment,
+            migration: <<~RUBY
+              remove_index :#{index.table.name}, :#{index.name}
+            RUBY
         end
 
         def recreate_index original_index, updated_index
@@ -82,18 +92,28 @@ module DynamicMigrations
             raise MissingDescriptionError
           end
 
-          add_migration index.table.schema.name, index.table.name, :set_index_comment, index.name, code_comment, <<~RUBY
-            set_index_comment :#{index.table.name}, :#{index.name}, <<~COMMENT
-              #{indent description}
-            COMMENT
-          RUBY
+          add_fragment schema: index.table.schema,
+            table: index.table,
+            migration_method: :set_index_comment,
+            object: index,
+            code_comment: code_comment,
+            migration: <<~RUBY
+              set_index_comment :#{index.table.name}, :#{index.name}, <<~COMMENT
+                #{indent description}
+              COMMENT
+            RUBY
         end
 
         # remove the comment from a index
         def remove_index_comment index, code_comment = nil
-          add_migration index.table.schema.name, index.table.name, :remove_index_comment, index.name, code_comment, <<~RUBY
-            remove_index_comment :#{index.table.name}, :#{index.name}
-          RUBY
+          add_fragment schema: index.table.schema,
+            table: index.table,
+            migration_method: :remove_index_comment,
+            object: index,
+            code_comment: code_comment,
+            migration: <<~RUBY
+              remove_index_comment :#{index.table.name}, :#{index.name}
+            RUBY
         end
       end
     end

data/lib/dynamic_migrations/postgres/generator/migration.rb

@@ -0,0 +1,175 @@
+module DynamicMigrations
+  module Postgres
+    class Generator
+      class Migration
+        class UnexpectedSchemaError < StandardError
+        end
+
+        class SectionNotFoundError < StandardError
+        end
+
+        class UnexpectedMigrationMethodNameError < StandardError
+        end
+
+        class DuplicateStructureTemplateError < StandardError
+        end
+
+        class NoFragmentsError < StandardError
+        end
+
+        # Defines a new section in the migration file, this is used to group
+        # migration fragments of the provided method names together under the
+        # provided header
+        def self.add_structure_template method_names, header
+          @structure_templates ||= []
+
+          if (@structure_templates.map { |s| s[:methods] }.flatten & method_names).any?
+            raise DuplicateStructureTemplateError, "Duplicate structure template for methods `#{method_names}`"
+          end
+
+          @structure_templates << {
+            methods: method_names,
+            header_comment: <<~COMMENT.strip
+              #
+              # #{header.strip}
+              #
+            COMMENT
+          }
+        end
+
+        # return the list of structure templates for use in this migration
+        def self.structure_templates
+          @structure_templates || []
+        end
+
+        # return the list of structure templates for use in this migration
+        def self.clear_structure_templates
+          @structure_templates = []
+        end
+
+        attr_reader :schema_name
+        attr_reader :fragments
+
+        def initialize schema_name
+          @schema_name = schema_name
+          @fragments = []
+        end
+
+        # Add a migration fragment to this migration, if the migration is not
+        # configured (via a structure template) to handle the method_name of the
+        # fragment, then am error is raised. An error will also be raised if the
+        # migration belongs to a different schema than the provided fragment.
+        def add_fragment fragment
+          raise UnexpectedSchemaError unless @schema_name == fragment.schema_name
+
+          unless supported_migration_method? fragment.migration_method
+            raise UnexpectedMigrationMethodNameError, "Expected method to be a valid migrator method, got `#{fragment.migration_method}`"
+          end
+
+          @fragments << fragment
+
+          fragment
+        end
+
+        # Return an array of table dependencies for this migration, this array comes from
+        # combining any table dependencies from each fragment.
+        # Will raise an error if no fragments have been provided.
+        def dependencies
+          raise NoFragmentsError if fragments.empty?
+          @fragments.map(&:dependency).compact
+        end
+
+        # removes and returns any fragments which have a dependency on the table with the
+        # provided schema_name and table_name, this is used for extracting fragments which
+        # cause circular dependencies so they can be placed into their own migrations
+        def extract_fragments_with_dependency schema_name, table_name
+          results = @fragments.filter { |f| f.is_dependent_on? schema_name, table_name }
+          # remove any of these from the internal array of fragments
+          @fragments.filter! { |f| !f.is_dependent_on?(schema_name, table_name) }
+          # return the results
+          results
+        end
+
+        # Combine the fragments, and build a string representation of the migration
+        # using the structure templates defined in this class.
+        # Will raise an error if no fragments have been provided.
+        def content
+          raise NoFragmentsError if fragments.empty?
+          sections = []
+          self.class.structure_templates.each do |section|
+            # add the header comment if we have a migration which matches one of the
+            # methods in this section
+            if (section[:methods] & @fragments.map(&:migration_method)).any?
+              sections << section[:header_comment].strip
+            end
+
+            # iterate through this sections methods in order and look
+            # for any that match the migrations we have
+            section[:methods].each do |migration_method|
+              # if we have any migration fragments for this method then add them
+              @fragments.filter { |f| f.migration_method == migration_method }.each do |fragment|
+                sections << fragment.to_s
+                sections << ""
+              end
+            end
+          end
+          sections.join("\n").strip
+        end
+
+        # Using the migration fragments, generate a friendly/descriptive name for the migration.
+        # Will raise an error if no fragments have been provided.
+        def name
+          raise NoFragmentsError if fragments.empty?
+
+          if fragments_for_method? :create_schema
+            "create_#{first_fragment_using_migration_method(:create_schema).schema_name}_schema".to_sym
+
+          elsif fragments_for_method? :drop_schema
+            "drop_#{first_fragment_using_migration_method(:drop_schema).schema_name}_schema".to_sym
+
+          elsif fragments_for_method? :create_table
+            "create_#{first_fragment_using_migration_method(:create_table).table_name}".to_sym
+
+          elsif fragments_for_method? :drop_table
+            "drop_#{first_fragment_using_migration_method(:drop_table).table_name}".to_sym
+
+          elsif all_fragments_for_method? [:create_function]
+            "create_function_#{@fragments.find { |s| s.migration_method == :create_function }&.object_name}".to_sym
+
+          elsif all_fragments_for_method? [:create_function, :update_function, :drop_function, :set_function_comment, :remove_function_comment]
+            :schema_functions
+
+          elsif @fragments.first&.table_name
+            "changes_for_#{@fragments.first&.table_name}".to_sym
+
+          else
+            :changes
+          end
+        end
+
+        private
+
+        def supported_migration_method? method_name
+          self.class.structure_templates.map { |s| s[:methods] }.flatten.include? method_name
+        end
+
+        def fragments_for_method? migration_method
+          @fragments.map(&:migration_method).include? migration_method
+        end
+
+        def first_fragment_using_migration_method migration_method
+          fragment = @fragments.find(&:migration_method)
+          if fragment.nil?
+            raise SectionNotFoundError, "No fragment of type #{migration_method} found"
+          end
+          fragment
+        end
+
+        # return true if the current migration only has the provided content types and comments
+        def all_fragments_for_method? migration_methods
+          (@fragments.map(&:migration_method) - migration_methods - [:comment]).empty?
+        end
+      end
+    end
+  end
+end

data/lib/dynamic_migrations/postgres/generator/migration_dependency_sorter.rb

@@ -0,0 +1,21 @@
+# TSort is a module included in the Ruby standard library for
+# executing topological sorts. We use it here to sort the migration
+# fragments so that they are executed in the correct order (i.e. tables
+# which have foreign keys are created after the tables they point to).
+require "tsort"
+
+module DynamicMigrations
+  module Postgres
+    class Generator
+      class MigrationDependencySorter < Hash
+        include TSort
+
+        alias_method :tsort_each_node, :each_key
+
+        def tsort_each_child(node, &block)
+          fetch(node).each(&block)
+        end
+      end
+    end
+  end
+end

data/lib/dynamic_migrations/postgres/generator/primary_key.rb

@@ -22,15 +22,25 @@ module DynamicMigrations
 
           options_syntax = options.map { |k, v| "#{k}: #{v}" }.join(", ")
 
-          add_migration primary_key.table.schema.name, primary_key.table.name, :add_primary_key, primary_key.name, code_comment, <<~RUBY
-            add_primary_key :#{primary_key.table.name}, #{column_names}, #{options_syntax}
-          RUBY
+          add_fragment schema: primary_key.table.schema,
+            table: primary_key.table,
+            migration_method: :add_primary_key,
+            object: primary_key,
+            code_comment: code_comment,
+            migration: <<~RUBY
+              add_primary_key :#{primary_key.table.name}, #{column_names}, #{options_syntax}
+            RUBY
         end
 
         def remove_primary_key primary_key, code_comment = nil
-          add_migration primary_key.table.schema.name, primary_key.table.name, :remove_primary_key, primary_key.name, code_comment, <<~RUBY
-            remove_primary_key :#{primary_key.table.name}, :#{primary_key.name}
-          RUBY
+          add_fragment schema: primary_key.table.schema,
+            table: primary_key.table,
+            migration_method: :remove_primary_key,
+            object: primary_key,
+            code_comment: code_comment,
+            migration: <<~RUBY
+              remove_primary_key :#{primary_key.table.name}, :#{primary_key.name}
+            RUBY
         end
 
         def recreate_primary_key original_primary_key, updated_primary_key