dynamic_migrations 3.8.6 → 3.8.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 00405e194209e083433ebb55aa305922a16e24290ead4f240420602c9465bc90
-  data.tar.gz: 57b7136d7eb1f7efc5382101cf24a4dc5ed4852e66a5f67faf368294e05632c0
+  metadata.gz: d822c8e95efe29d0f03f07162f27909ba4222ab4be98c421d64bd167fe923443
+  data.tar.gz: 88a20111dae2a34872d0759f47a0c8c29eab87d354ebb7a55d33152c9d06c6e3
 SHA512:
-  metadata.gz: bc594cb118caa67c0e9982f839c762e074b789b083328a1b69b3261297bd34055a53739f51cabb6f6e5685ea76f80eb4574b45649fd202bf213a579713842fac
-  data.tar.gz: 8d42ee7274c26e25086eae4e9c2646f958f930a18fd03eb9c6262f734cf55af380499763e3508a05156a6f1baad4c7bc30007e9d242674d9594bf83e75a7bf1f
+  metadata.gz: 2210081126891f62ebadb6dd9f9f53cafd5cdd7ae196558b00e94ffdf91b64b1686d65c95ec07357ee8043ba1e8c698812ed07503d8b46287ab5496e26beb46d
+  data.tar.gz: eb23900019d373320e0f2510eadd2714c1c2c4324af0b0a4f68886754204deb7ebc0de11f833bf43b0a53b38f80448b70370ccd57ca55005c97715c397f4b579

data/CHANGELOG.md

@@ -1,5 +1,32 @@
 # Changelog
 
+## [3.8.8](https://github.com/craigulliott/dynamic_migrations/compare/v3.8.7...v3.8.8) (2023-10-11)
+
+
+### Bug Fixes
+
+* adding a specific error type for invalid names ([12df7bd](https://github.com/craigulliott/dynamic_migrations/commit/12df7bddcb947d3ab5b1b00eebefdda0a3ce15ac))
+* fixed bug where check_clause and action_condition were being modified, also freezing strings to prevent similar bugs in the future ([dc1191b](https://github.com/craigulliott/dynamic_migrations/commit/dc1191b7e219b73da8469742259686721265a2a7))
+* removed arbitrary column name sorting, as we want migrations to create columns in the order they were added ([e9a515e](https://github.com/craigulliott/dynamic_migrations/commit/e9a515eb9dbf16ef5a5e77ca0084a6514690530b))
+* removing deferrable and initially deferred from check constraints because postgres doesn't support them ([945aef2](https://github.com/craigulliott/dynamic_migrations/commit/945aef2419fd5f55a0551929244f3f9b0a29a905))
+* should not have assumed enums in the same schema use their short name, enums are always referenced by their full name (including schema) ([a9863ba](https://github.com/craigulliott/dynamic_migrations/commit/a9863ba49727e5016c8eae74f5f2a6e7ab8c1042))
+* we were not resolving the correct deferred and initially_deferred values when loading existing database structure ([02c539a](https://github.com/craigulliott/dynamic_migrations/commit/02c539a8ea153cde6d06f6be6d8fdb0aaf851f40))
+
+## [3.8.7](https://github.com/craigulliott/dynamic_migrations/compare/v3.8.6...v3.8.7) (2023-10-09)
+
+
+### Bug Fixes
+
+* added detection of missing extensions and better error messages when normalizing check_constrains and action_conditions ([d82ff57](https://github.com/craigulliott/dynamic_migrations/commit/d82ff57f5b51c8636e87b40b8d6b016d11e6c72a))
+* added enum value length validation ([d82ff57](https://github.com/craigulliott/dynamic_migrations/commit/d82ff57f5b51c8636e87b40b8d6b016d11e6c72a))
+* also drastic performance improvement of migration circular dependency resolution ([2915b8f](https://github.com/craigulliott/dynamic_migrations/commit/2915b8f28c9202bd18f221cfafa2c4352a80fd2c))
+* fixed regex for validating name within migration fragment (it was not allowing a single letter followed by an underscore) ([9b73eca](https://github.com/craigulliott/dynamic_migrations/commit/9b73ecac03816cc74f9b0d23084d0cfb09701012))
+* migration generation now finds and resolves circular dependencies which exist through N migrations (it used to only resolve immediate circular dependencies) ([2915b8f](https://github.com/craigulliott/dynamic_migrations/commit/2915b8f28c9202bd18f221cfafa2c4352a80fd2c))
+* providing the table dependency to all enum and function migrations if there is only one table which they rely on ([3d3708d](https://github.com/craigulliott/dynamic_migrations/commit/3d3708dfb7bdd2a83a477087ac22fd540ae1f881))
+* reducing some log messages from info level to debug level ([cdf1200](https://github.com/craigulliott/dynamic_migrations/commit/cdf12000186a9e373d5085f83d2fb197c7796c6c))
+* table migrations now allow enum related fragments ([b894bf1](https://github.com/craigulliott/dynamic_migrations/commit/b894bf14743c51b505693818407ba6bfb3f31571))
+* updating log level for some log entries ([456a90e](https://github.com/craigulliott/dynamic_migrations/commit/456a90e7fe6da78667a84928b75217f89c344f35))
+
 ## [3.8.6](https://github.com/craigulliott/dynamic_migrations/compare/v3.8.5...v3.8.6) (2023-10-08)
 
 

data/lib/dynamic_migrations/active_record/migrators/validation.rb

@@ -3,7 +3,7 @@ module DynamicMigrations
     module Migrators
       module Validation
         # this exists because because the standard rails migration does not support deffered constraints
-        def add_validation table_name, name:, initially_deferred: false, deferrable: false, comment: nil, &block
+        def add_validation table_name, name:, comment: nil, &block
           unless block
             raise MissingFunctionBlockError, "create_function requires a block"
           end
@@ -12,28 +12,10 @@ module DynamicMigrations
             sql = block.call.strip
           end
 
-          if initially_deferred == true && deferrable == false
-            raise DeferrableOptionsError, "A constraint can only be initially deferred if it is also deferrable"
-          end
-
-          # allow it to be deferred, and defer it by default
-          deferrable_sql = if initially_deferred
-            "DEFERRABLE INITIALLY DEFERRED"
-
-          # allow it to be deferred, but do not deferr by default
-          elsif deferrable
-            "DEFERRABLE INITIALLY IMMEDIATE"
-
-          # it can not be deferred (this is the default)
-          else
-            "NOT DEFERRABLE"
-          end
-
           execute <<~SQL
             ALTER TABLE #{table_name}
               ADD CONSTRAINT #{name}
-                CHECK (#{sql})
-                #{deferrable_sql};
+                CHECK (#{sql});
           SQL
 
           if comment.is_a? String

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

@@ -6,16 +6,8 @@ module DynamicMigrations
         end
 
         def create_enum enum, code_comment = nil
-          # we only provide a table if the enum has a single column and they
-          # are in the same schema, otherwise we can't reliable handle dependencies
-          # so the enum will be created in the schema's migration
-          enum_table = nil
-          if enum.columns.count == 1 && enum.schema == enum.columns.first&.table&.schema
-            enum_table = enum.columns.first&.table
-          end
-
           add_fragment schema: enum.schema,
-            table: enum_table,
+            table: optional_enum_table(enum),
             migration_method: :create_enum,
             object: enum,
             code_comment: code_comment,
@@ -35,6 +27,7 @@ module DynamicMigrations
           end
 
           add_fragment schema: updated_enum.schema,
+            table: optional_enum_table(updated_enum),
             migration_method: :add_enum_values,
             object: updated_enum,
             code_comment: code_comment,
@@ -47,6 +40,7 @@ module DynamicMigrations
 
         def drop_enum enum, code_comment = nil
           add_fragment schema: enum.schema,
+            table: optional_enum_table(enum),
             migration_method: :drop_enum,
             object: enum,
             code_comment: code_comment,
@@ -58,6 +52,7 @@ module DynamicMigrations
         # add a comment to a enum
         def set_enum_comment enum, code_comment = nil
           add_fragment schema: enum.schema,
+            table: optional_enum_table(enum),
             migration_method: :set_enum_comment,
             object: enum,
             code_comment: code_comment,
@@ -71,6 +66,7 @@ module DynamicMigrations
         # remove the comment from a enum
         def remove_enum_comment enum, code_comment = nil
           add_fragment schema: enum.schema,
+            table: optional_enum_table(enum),
             migration_method: :remove_enum_comment,
             object: enum,
             code_comment: code_comment,
@@ -78,6 +74,14 @@ module DynamicMigrations
               remove_enum_comment :#{enum.name}
             RUBY
         end
+
+        # we only provide a table to these migration fragments if the enum applies only to one table
+        # and that take is in the same schema as the enum
+        def optional_enum_table enum
+          # all the tables which use this enum
+          tables = enum.columns.map(&:table).uniq
+          (tables.count == 1 && tables.first&.schema == enum.schema) ? tables.first : nil
+        end
       end
     end
   end

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

@@ -5,6 +5,9 @@ module DynamicMigrations
         class InvalidNameError < StandardError
         end
 
+        class ContentRequiredError < StandardError
+        end
+
         attr_reader :schema_name
         attr_reader :table_name
         attr_reader :migration_method
@@ -15,7 +18,7 @@ module DynamicMigrations
         attr_reader :dependency_enum_name
 
         def initialize schema_name, table_name, migration_method, object_name, code_comment, content
-          valid_name_regex = /\A[a-z][a-z0-9]+(_[a-z0-9]+)*\z/
+          valid_name_regex = /\A[a-z][a-z0-9]*(_[a-z0-9]+)*\z/
 
           unless schema_name.nil? || (schema_name.to_s.match valid_name_regex)
             raise InvalidNameError, "Invalid schema name `#{schema_name}`, must only be lowercase letters, numbers and underscores"
@@ -33,8 +36,12 @@ module DynamicMigrations
           @object_name = object_name
 
           @migration_method = migration_method
-          @code_comment = code_comment
-          @content = content
+          @code_comment = code_comment&.freeze
+
+          if content.nil?
+            raise ContentRequiredError, "Content is required for a fragment"
+          end
+          @content = content.freeze
         end
 
         # Returns a string representation of the fragment for use in the final

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

@@ -21,16 +21,8 @@ module DynamicMigrations
 
           fn_sql = function.definition.strip
 
-          # we only provide a table if the function has a single trigger and they
-          # are in the same schema, otherwise we can't reliable handle dependencies
-          # so the function will be created in the schema's migration
-          function_table = nil
-          if function.triggers.count == 1 && function.schema == function.triggers.first&.table&.schema
-            function_table = function.triggers.first&.table
-          end
-
           add_fragment schema: function.schema,
-            table: function_table,
+            table: optional_function_table(function),
             migration_method: :create_function,
             object: function,
             code_comment: code_comment,
@@ -47,7 +39,7 @@ module DynamicMigrations
           fn_sql = function.definition.strip
 
           add_fragment schema: function.schema,
-            table: function.triggers.first&.table,
+            table: optional_function_table(function),
             migration_method: :update_function,
             object: function,
             code_comment: code_comment,
@@ -62,7 +54,7 @@ module DynamicMigrations
 
         def drop_function function, code_comment = nil
           add_fragment schema: function.schema,
-            table: function.triggers.first&.table,
+            table: optional_function_table(function),
             migration_method: :drop_function,
             object: function,
             code_comment: code_comment,
@@ -74,7 +66,7 @@ module DynamicMigrations
         # add a comment to a function
         def set_function_comment function, code_comment = nil
           add_fragment schema: function.schema,
-            table: function.triggers.first&.table,
+            table: optional_function_table(function),
             migration_method: :set_function_comment,
             object: function,
             code_comment: code_comment,
@@ -88,7 +80,7 @@ module DynamicMigrations
         # remove the comment from a function
         def remove_function_comment function, code_comment = nil
           add_fragment schema: function.schema,
-            table: function.triggers.first&.table,
+            table: optional_function_table(function),
             migration_method: :remove_function_comment,
             object: function,
             code_comment: code_comment,
@@ -96,6 +88,14 @@ module DynamicMigrations
               remove_function_comment :#{function.name}
             RUBY
         end
+
+        # we only provide a table to these migration fragments if the function applies only to one table
+        # and that take is in the same schema as the function
+        def optional_function_table function
+          # all the tables which use this function
+          tables = function.triggers.map(&:table).uniq
+          (tables.count == 1 && tables.first&.schema == function.schema) ? tables.first : nil
+        end
       end
     end
   end

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

@@ -67,6 +67,39 @@ module DynamicMigrations
           @structure_templates = []
         end
 
+        def to_s
+          # because calling these methods will rise an error if there are no
+          # fragments, and this method is primarily used for debugging
+          if @fragments.any?
+            tds = table_dependencies
+            eds = enum_dependencies
+            fds = function_dependencies
+          else
+            tds = []
+            eds = []
+            fds = []
+          end
+          <<~PREVIEW.strip
+            # Migration content preview
+            # -------------------------
+            # Schema:#{@schema_name ? " #{@schema_name}" : ""}
+            # Table:#{@table_name ? " #{@table_name}" : ""}
+
+            # Table Dependencies (count: #{tds.count}):
+            #{(tds.any? ? "#   " : "") + tds.map { |d| "Schema: `#{d[:schema_name]}` Table: `#{d[:table_name]}`" }.join("\n#   ")}
+
+            # Enum Dependencies (count: #{eds.count}):
+            #{(eds.any? ? "#   " : "") + eds.map { |d| "Schema: `#{d[:schema_name]}` Enum: `#{d[:enum_name]}`" }.join("\n#   ")}
+
+            # Function Dependencies (count: #{fds.count}):
+            #{(fds.any? ? "#   " : "") + fds.map { |d| "Schema: `#{d[:schema_name]}` Function: `#{d[:function_name]}`" }.join("\n#   ")}
+
+            # Fragments (count: #{@fragments.count}):
+
+            #{@fragments.map(&:to_s).join("\n\n")}
+          PREVIEW
+        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
@@ -95,32 +128,37 @@ module DynamicMigrations
 
         # 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.
+        # Will raise an error if no fragments are available.
         def table_dependencies
           raise NoFragmentsError if fragments.empty?
-          @fragments.map(&:table_dependency).compact
+          @fragments.map(&:table_dependency).compact.uniq
         end
 
         # Return an array of function dependencies for this migration, this array comes from
         # combining any function dependencies from each fragment.
-        # Will raise an error if no fragments have been provided.
+        # Will raise an error if no fragments are available.
         def function_dependencies
           raise NoFragmentsError if fragments.empty?
-          @fragments.map(&:function_dependency).compact
+          @fragments.map(&:function_dependency).compact.uniq
         end
 
         # Return an array of enum dependencies for this migration, this array comes from
         # combining any enum dependencies from each fragment.
-        # Will raise an error if no fragments have been provided.
+        # Will raise an error if no fragments are available.
         def enum_dependencies
           raise NoFragmentsError if fragments.empty?
-          @fragments.map(&:enum_dependency).compact
+          @fragments.map(&:enum_dependency).compact.uniq
+        end
+
+        # returns the number of fragment within this migration which have the provided dependency
+        def fragments_with_table_dependency_count schema_name, table_name
+          @fragments.count { |f| f.is_dependent_on_table? schema_name, table_name }
         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
+        def extract_fragments_with_table_dependency schema_name, table_name
           results = @fragments.filter { |f| f.is_dependent_on_table? schema_name, table_name }
           # remove any of these from the internal array of fragments
           @fragments.filter! { |f| !f.is_dependent_on_table?(schema_name, table_name) }

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

@@ -15,6 +15,8 @@ module DynamicMigrations
         add_structure_template [:drop_table], "Remove Tables"
         add_structure_template [:create_table], "Create Table"
         add_structure_template [:remove_table_comment, :set_table_comment], "Tables"
+        add_structure_template [:remove_enum_comment, :drop_enum], "Drop Enums"
+        add_structure_template [:create_enum, :add_enum_values, :set_enum_comment], "Enums"
         add_structure_template [:add_column], "Additional Columns"
         add_structure_template [:change_column, :remove_column_comment, :set_column_comment], "Update Columns"
         add_structure_template [:add_primary_key, :set_primary_key_comment, :remove_primary_key_comment], "Primary Key"

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

@@ -38,9 +38,7 @@ module DynamicMigrations
           else
 
             options = {
-              name: ":#{validation.name}",
-              deferrable: validation.deferrable,
-              initially_deferred: validation.initially_deferred
+              name: ":#{validation.name}"
             }
 
             if validation.description.nil?

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

@@ -10,17 +10,11 @@ module DynamicMigrations
 
         def initialize validation, code_comment
           @validation = validation
-          @code_comment = code_comment
+          @code_comment = code_comment&.freeze
         end
 
         private
 
-        def assert_not_deferred!
-          if @validation.initially_deferred || @validation.deferrable
-            raise TemplateError, "#{self.class.name} validation template requires constraints to be are not deferrable"
-          end
-        end
-
         def assert_column_count! count = 1
           if @validation.columns.count != count
             raise TemplateError, "#{self.class.name} validation template requires a validation with only #{count} column"

data/lib/dynamic_migrations/postgres/generator.rb

@@ -34,10 +34,13 @@ module DynamicMigrations
 
       def initialize
         @fragments = []
+        @logger = Logging.logger[self]
       end
 
       # builds the final migrations
       def migrations
+        log.info "Generating migrations"
+
         # a hash to hold the generated migrations orgnized by their schema and table
         # this makes it easier and faster to work with them within this method
         database_migrations = {}
@@ -49,6 +52,7 @@ module DynamicMigrations
         # Process each fragment, and organize them into migrations. We create a shared
         # Migration for each table, and a single shared migration for any schema migrations
         # which do not relate to a table.
+        log.info "  Organizing migration fragments"
         @fragments.each do |fragment|
           # The first time this schema is encountered we create an object to hold the migrations
           # and organize the different migrations.
@@ -87,32 +91,23 @@ module DynamicMigrations
 
         # Convert the hash of migrations into an array of migrations, this is
         # passed to the `circular_dependency?` method below, and any new migrations
-        # requred to resolve circular dependencies will be added to this array
+        # required to resolve circular dependencies will be added to this array
         all_table_migrations = database_migrations.values.map { |m| m[:table_migrations].values }.flatten
 
-        # iterate through all of the table migrations, and fix any circular dependencies caused
-        # by foreign key constraints
-        database_migrations.each do |schema_name, schema_migrations|
-          # we only need to process the TableMigrations, as the SchemaMigration
-          # never have dependencies
-          schema_migrations[:table_migrations].values.each do |table_migration|
-            # recursively test each table migration for circular dependencies
-            table_migration.table_dependencies.each do |dependency|
-              if circular_dependency? table_migration.schema_name, table_migration.table_name, dependency, all_table_migrations
-                # remove the fragment which is causing the circular dependency
-                removed_fragments = table_migration.extract_fragments_with_dependency dependency[:schema_name], dependency[:table_name]
-                # create a new table migration for these fragments (there should only
-                # be one, but we treat them as an array to futiure proof this)
-                new_migration = TableMigration.new(schema_name, table_migration.table_name)
-                # place these fragments in their own migration
-                removed_fragments.each do |removed_fragment|
-                  new_migration.add_fragment removed_fragment
-                end
-                # add the new migration to the list of migrations
-                schema_migrations[:additional_migrations] << new_migration
-              end
-            end
-          end
+        # For each migration, we recursively traverse the dependency graph to detect and handle circular
+        # dependencies.
+        #
+        # Initially, all the fragments which pertain to a particular table are grouped together in
+        # the same migration. If a circular dependency between migrations is detected, then we simply
+        # pop the offending migration fragments out of the dedicated table migration and into a new
+        # migration. This allows the migration to be processed later, and resolves the circular dependency.
+        log.info "  Resolving circular dependencies between migrations"
+        completed_table_migrations = []
+        all_table_migrations.each do |table_migration|
+          # skip it if it's already been processed
+          next if completed_table_migrations.include? table_migration
+          # recusrsively resolve the circular dependencies for this migration
+          resolve_circular_dependencies table_migration, all_table_migrations, database_migrations, completed_table_migrations
         end
 
         # Prepare a dependency sorter, this is used to sort the migrations via rubys included Tsort module
@@ -123,6 +118,7 @@ module DynamicMigrations
         #   migration1 => [migration2, migration3],
         #   migration3 => [migration2]
         # }
+        log.info "  Preparing migrations for sorting"
         dependency_sorter = MigrationDependencySorter.new
         database_migrations.each do |schema_name, schema_migrations|
           if schema_migrations[:schema_migration]
@@ -161,13 +157,24 @@ module DynamicMigrations
             # if there is a schema migration, then it should always come first
             # so make the table migration depend on it
             deps << schema_migrations[:schema_migration] if schema_migrations[:schema_migration]
+
             # additional migrations are always dependent on the table migration which they came from
             table_migration = schema_migrations[:table_migrations][additional_migration.table_name]
             # if the table migration is not found, then it's safe to assume the table was created
             # by an earlier set of migrations
             unless table_migration.nil?
               deps << table_migration
+
+              # if the table migration has any dependencies on functions or enums, then add them
+              (table_migration.function_dependencies + table_migration.enum_dependencies).each do |dependency|
+                # functions are always added to a schema specific migration, if it does not exist then
+                # we can assume the function was added in a previous set of migrations
+                if (dependencies_schema_migration = database_migrations[dependency[:schema_name]] && database_migrations[dependency[:schema_name]][:schema_migration])
+                  deps << dependencies_schema_migration
+                end
+              end
             end
+
             # if the additional_migration has any dependencies on other tables, then add them too
             additional_migration.table_dependencies.each do |dependency|
               # find the table migration which matches the dependency
@@ -178,19 +185,12 @@ module DynamicMigrations
                 deps << dependent_migration
               end
             end
-            # if the table migration has any dependencies on functions or enums, then add them
-            (table_migration.function_dependencies + table_migration.enum_dependencies).each do |dependency|
-              # functions are always added to a schema specific migration, if it does not exist then
-              # we can assume the function was added in a previous set of migrations
-              if (dependencies_schema_migration = database_migrations[dependency[:schema_name]] && database_migrations[dependency[:schema_name]][:schema_migration])
-                deps << dependencies_schema_migration
-              end
-            end
           end
         end
 
         # sort the migrations so that they are executed in the correct order
         # the order is determined by their dependencies
+        log.info "  Sorting migrations based on their dependencies"
         final_migrations = dependency_sorter.tsort
 
         # if any database only migrations exist, then add them to the front of the array here
@@ -210,23 +210,73 @@ module DynamicMigrations
 
       private
 
-      def circular_dependency? schema_name, table_name, dependency, all_table_migrations
-        # if the current dependency (schema_name and table_name) matches the original migration then we have a circular dependency
-        if dependency[:schema_name] == schema_name && dependency[:table_name] == table_name
-          true
-        else
-          # get all mirations which are for the same schema and table as the dependency
-          dependent_migrations = all_table_migrations.filter { |m| m.schema_name == dependency[:schema_name] && m.table_name == dependency[:table_name] }
-          # recursively call this method for all the dependencies for these migrations
-          dependent_migrations.each do |dependent_migration|
-            dependent_migration.table_dependencies.each do |next_dependency|
-              # if we find a dependency which matches the original schema and table name then we have a circular dependency
-              if circular_dependency?(schema_name, table_name, next_dependency, all_table_migrations)
-                return true
+      # Initially, all the fragments which pertain to a particular table are grouped together in
+      # the same migration. If a circular dependency between migrations is detected, then we simply
+      # pop the offending migration fragments out of the dedicated table migration and into a new
+      # migration. This allows the migration to be processed later, and resolves the circular dependency.
+      #
+      # Note, "table migrations" are the default migrations which initially contain all the fragments for
+      # a particular table.
+      #
+      # `table_migration` is the current migration which is being processed
+      # `all_table_migrations` is all the table migrations in this current set of migrations
+      # `database_migrations` is a hash of all the migrations, organized by schema and table, we need this
+      # object so that we can add any new migrations which are created to resolve circular dependencies
+      # `completed_table_migrations` is an array of all the table migrations which have already been
+      # processed, we use this for performance reasons, so that we dont process the same migration twice
+      # `stack` is an array of all the migrations which have been processed so far in this current recursive
+      # path, this is used to detect circular dependencies.
+      def resolve_circular_dependencies table_migration, all_table_migrations, database_migrations, completed_table_migrations, stack = []
+        # process all the current dependencies for this migration
+        # each dependency is a hash, with the schema_name and table_name
+        table_migration.table_dependencies.each do |dependency|
+          # look in the list of all table migrations and try and find the migration which
+          # matches the current dependency, note that this migration may not exist because
+          # the table could have been created in a previous set of migrations
+          if (next_table_migration = all_table_migrations.find { |m| m.schema_name == dependency[:schema_name] && m.table_name == dependency[:table_name] })
+            # if this migration has already been processed, then we can skip it
+            next if completed_table_migrations.include? next_table_migration
+
+            key = "#{next_table_migration.schema_name}.#{next_table_migration.table_name}"
+            # if this migration already exists in the stack, then we have a circular dependency
+            if stack.include? key
+              log.info "    Resolving circular dependency for #{table_migration.schema_name}.#{table_migration.table_name} -> #{next_table_migration.schema_name}.#{next_table_migration.table_name}"
+
+              # if the number of fragments in the table migration is equal to the number of fragments
+              # which would be removed, then there is no need to split the migration
+              next if table_migration.fragments.count == table_migration.fragments_with_table_dependency_count(next_table_migration.schema_name, next_table_migration.table_name)
+
+              # remove the fragments which are causing the circular dependency
+              removed_fragments = table_migration.extract_fragments_with_table_dependency next_table_migration.schema_name, next_table_migration.table_name
+
+              # create a new table migration for these fragments
+              new_migration = TableMigration.new(table_migration.schema_name, table_migration.table_name)
+
+              # place these fragments in their own migration
+              removed_fragments.each do |removed_fragment|
+                new_migration.add_fragment removed_fragment
               end
+
+              # add the new migration to the list of additional (not standard table migrations) for
+              # this schema
+              database_migrations[table_migration.schema_name][:additional_migrations] << new_migration
+
+              # continue to the next dependency
+              next
             end
+
+            # create a new stack, so that each recursive call has it's own copy
+            new_stack = stack + [key]
+
+            # recursively move on to the next migration
+            resolve_circular_dependencies next_table_migration, all_table_migrations, database_migrations, completed_table_migrations, new_stack
+
+            # when the code reaches this point, we have completed the recursive traversal of
+            # all the dependencies originating from next_table_migration, so we can add it to
+            # the array of completed migrations, note that this array is shared across all
+            # recursive calls, so that we can keep track of which migrations have been processed
+            completed_table_migrations << next_table_migration
           end
-          false
         end
       end
 
@@ -274,6 +324,10 @@ module DynamicMigrations
       def trim_lines string
         string.split("\n").map(&:rstrip).join("\n")
       end
+
+      def log
+        @logger
+      end
     end
   end
 end

data/lib/dynamic_migrations/postgres/server/database/differences/to_migrations/extensions.rb

@@ -11,14 +11,14 @@ module DynamicMigrations
                 # if the extension exists in the configuration but not in the database
                 # then we have to create it
                 if configuration_extension[:exists] == true && !database_extension[:exists]
-                  log.info "Extension `#{extension_name}` exists in configuration but not in the database"
+                  log.debug "Extension `#{extension_name}` exists in configuration but not in the database"
                   # a migration to create the extension
                   @generator.enable_extension extension_name
 
                 # if the extension exists in the database but not in the configuration
                 # then we need to delete it
                 elsif database_extension[:exists] == true && !configuration_extension[:exists]
-                  log.info "Extension `#{extension_name}` exists in database but not in the configuration"
+                  log.debug "Extension `#{extension_name}` exists in database but not in the configuration"
                   # a migration to drop the extension
                   if Postgres.remove_unused_extensions?
                     @generator.disable_extension extension_name