dynamic_migrations 2.2.0 → 3.1.0

data/lib/dynamic_migrations/postgres/generator.rb

@@ -0,0 +1,359 @@
+module DynamicMigrations
+  module Postgres
+    class Generator
+      class ExpectedSymbolError < StandardError
+      end
+
+      class DeferrableOptionsError < StandardError
+      end
+
+      class UnexpectedMigrationMethodNameError < StandardError
+      end
+
+      class MissingDescriptionError < StandardError
+      end
+
+      class NoDifferenceError < StandardError
+      end
+
+      # these sections are in order for which they will appear in a migration,
+      # note that removals come before additions, and that the order here optomizes
+      # for dependencies (i.e. columns have to be created before indexes are added and
+      # triggers are removed before functions are dropped)
+      STRUCTURE = [
+        {
+          header_comment: <<~COMMENT,
+            #
+            # Remove Functions
+            #
+          COMMENT
+          methods: [
+            :remove_function_comment,
+            :drop_function
+          ]
+        },
+        {
+          header_comment: <<~COMMENT,
+            #
+            # Remove Triggers
+            #
+          COMMENT
+          methods: [
+            :remove_trigger_comment,
+            :remove_trigger
+          ]
+        },
+        {
+          header_comment: <<~COMMENT,
+            #
+            # Remove Validations
+            #
+          COMMENT
+          methods: [
+            :remove_validation,
+            :remove_unique_constraint
+          ]
+        },
+        {
+          header_comment: <<~COMMENT,
+            #
+            # Remove Foreign Keys
+            #
+          COMMENT
+          methods: [
+            :remove_foreign_key
+          ]
+        },
+        {
+          header_comment: <<~COMMENT,
+            #
+            # Remove Primary Keys
+            #
+          COMMENT
+          methods: [
+            :remove_primary_key
+          ]
+        },
+        {
+          header_comment: <<~COMMENT,
+            #
+            # Remove Indexes
+            #
+          COMMENT
+          methods: [
+            :remove_index,
+            :remove_index_comment
+          ]
+        },
+        {
+          header_comment: <<~COMMENT,
+            #
+            # Remove Columns
+            #
+          COMMENT
+          methods: [
+            :remove_column
+          ]
+        },
+        {
+          header_comment: <<~COMMENT,
+            #
+            # Remove Tables
+            #
+          COMMENT
+          break_after: true,
+          methods: [
+            :drop_table
+          ]
+        },
+        {
+          # this is important enough to get it's own migration
+          break_before: true,
+          break_after: true,
+          header_comment: <<~COMMENT,
+            #
+            # Drop this schema
+            #
+          COMMENT
+          methods: [
+            :drop_schema
+          ]
+        },
+        {
+          # this is important enough to get it's own migration
+          break_before: true,
+          break_after: true,
+          header_comment: <<~COMMENT,
+            #
+            # Create this schema
+            #
+          COMMENT
+          methods: [
+            :create_schema
+          ]
+        },
+        {
+          header_comment: <<~COMMENT,
+            #
+            # Create Table
+            #
+          COMMENT
+          methods: [
+            :create_table
+          ]
+        },
+        {
+          header_comment: <<~COMMENT,
+            #
+            # Tables
+            #
+          COMMENT
+          methods: [
+            :remove_table_comment,
+            :set_table_comment
+          ]
+        },
+        {
+          header_comment: <<~COMMENT,
+            #
+            # Additional Columns
+            #
+          COMMENT
+          methods: [
+            :add_column
+          ]
+        },
+        {
+          header_comment: <<~COMMENT,
+            #
+            # Update Columns
+            #
+          COMMENT
+          methods: [
+            :change_column,
+            :remove_column_comment,
+            :set_column_comment
+          ]
+        },
+        {
+          header_comment: <<~COMMENT,
+            #
+            # Primary Key
+            #
+          COMMENT
+          methods: [
+            :add_primary_key
+          ]
+        },
+        {
+          header_comment: <<~COMMENT,
+            #
+            # Indexes
+            #
+          COMMENT
+          methods: [
+            :add_index,
+            :set_index_comment
+          ]
+        },
+        {
+          header_comment: <<~COMMENT,
+            #
+            # Foreign Keys
+            #
+          COMMENT
+          methods: [
+            :add_foreign_key,
+            :set_foreign_key_constraint_comment,
+            :remove_foreign_key_constraint_comment
+          ]
+        },
+        {
+          header_comment: <<~COMMENT,
+            #
+            # Validations
+            #
+          COMMENT
+          methods: [
+            :add_validation,
+            :add_unique_constraint,
+            :set_validation_comment,
+            :remove_validation_comment,
+            :set_unique_constraint_comment,
+            :remove_unique_constraint_comment
+          ]
+        },
+        {
+          header_comment: <<~COMMENT,
+            #
+            # Functions
+            #
+          COMMENT
+          methods: [
+            :create_function
+          ]
+        },
+        {
+          header_comment: <<~COMMENT,
+            #
+            # Triggers
+            #
+          COMMENT
+          methods: [
+            :add_trigger,
+            :set_trigger_comment
+          ]
+        },
+        {
+          header_comment: <<~COMMENT,
+            #
+            # Update Functions
+            #
+          COMMENT
+          methods: [
+            :update_function,
+            :set_function_comment
+          ]
+        }
+      ]
+
+      include Schema
+      include Table
+      include Column
+      include ForeignKeyConstraint
+      include Index
+      include PrimaryKey
+      include UniqueConstraint
+      include Validation
+      include Function
+      include Trigger
+
+      def initialize
+        @migrations = {}
+      end
+
+      # builds an array of migrations that can be used to create the provided schema
+      def migrations
+        final_migrations = {}
+        # an array of table names which have migrations, we group migrations for the same table together
+        @migrations.map do |schema_name, table_migrations|
+          schema_migrations = SchemaMigrations.new
+          # iterate through the tables which have migrations
+          table_migrations.map do |table_name, fragments|
+            # iterate through the structure object in order, and create the final migrations
+            STRUCTURE.each do |section|
+              # if this section requires a new migration, then end any current one
+              if section[:break_before]
+                schema_migrations.finalize
+              end
+
+              # add the header comment if we have a migration which matches one of the
+              # methods in this section
+              if (section[:methods] & fragments.keys).any?
+                header_fragment = Fragment.new nil, nil, section[:header_comment]
+                schema_migrations.add_fragment schema_name, table_name, :comment, header_fragment
+              end
+
+              # iterate through this sections methods in order and look
+              # for any that match the migrations we have
+              section[:methods].each do |method_name|
+                # if we have any migration fragments for this method then add them
+                fragments[method_name]&.each do |fragment|
+                  schema_migrations.add_fragment schema_name, table_name, method_name, fragment
+                end
+              end
+
+              # if this section causes a new migration then end any current one
+              if section[:break_after]
+                schema_migrations.finalize
+              end
+            end
+            schema_migrations.finalize
+          end
+          final_migrations[schema_name] = schema_migrations.to_a
+        end
+        final_migrations
+      end
+
+      private
+
+      def supported_migration_method_names
+        @supported_migration_method_names ||= STRUCTURE.map { |s| s[:methods] }.flatten
+      end
+
+      def supported_migration_method? method_name
+        supported_migration_method_names.include? method_name
+      end
+
+      def add_migration schema_name, table_name, migration_method, object_name, code_comment, migration
+        raise ExpectedSymbolError, "Expected schema_name to be a symbol, got #{schema_name}" unless schema_name.is_a?(Symbol)
+        raise ExpectedSymbolError, "Expected table_name to be a symbol, got #{table_name}" unless schema_name.is_a?(Symbol)
+
+        unless supported_migration_method? migration_method
+          raise UnexpectedMigrationMethodNameError, "Expected migration_method to be a valid migrator method, got `#{migration_method}`"
+        end
+
+        final_migration = strip_empty_lines(migration).strip
+        fragment = Fragment.new(object_name, code_comment, final_migration)
+
+        # note, table_name can be nil, which is OK because nil is a valid
+        # key and we do want to group them all together
+        @migrations[schema_name] ||= {}
+        @migrations[schema_name][table_name] ||= {}
+        @migrations[schema_name][table_name][migration_method] ||= []
+        @migrations[schema_name][table_name][migration_method] << fragment
+
+        # return the newly created migration fragment
+        fragment
+      end
+
+      def indent multi_line_string
+        multi_line_string.gsub("\n", "\n  ")
+      end
+
+      def strip_empty_lines multi_line_string
+        multi_line_string.gsub(/^\s*\n/, "")
+      end
+    end
+  end
+end

data/lib/dynamic_migrations/postgres/server/database/differences/to_migrations/schemas/functions.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module DynamicMigrations
+  module Postgres
+    class Server
+      class Database
+        class Differences
+          class ToMigrations
+            module Schemas
+              module Functions
+                def process_functions schema_name, configuration_functions, database_functions
+                  # process all the functions
+                  function_names = (configuration_functions.keys + database_functions.keys).uniq
+                  function_names.each do |function_name|
+                    process_function schema_name, function_name, configuration_functions[function_name] || {}, database_functions[function_name] || {}
+                  end
+                end
+
+                def process_function schema_name, function_name, configuration_function, database_function
+                  # If the function exists in the configuration but not in the database
+                  # then we have to create it.
+                  if configuration_function[:exists] == true && database_function[:exists] == false
+                    # a migration to create the function
+                    function = @database.configured_schema(schema_name).function(function_name)
+                    @generator.create_function function
+
+                  # If the schema exists in the database but not in the configuration
+                  # then we need to delete it.
+                  elsif configuration_function[:exists] == false && database_function[:exists] == true
+                    # a migration to create the function
+                    function = @database.loaded_schema(schema_name).function(function_name)
+                    @generator.drop_function function
+
+                  # If the function exists in both the configuration and database representations
+                  # but the definition is different then we need to update the definition.
+                  elsif configuration_function[:definition][:matches] == false
+                    function = @database.configured_schema(schema_name).function(function_name)
+                    @generator.update_function function
+                    # does the description also need to be updated
+                    if configuration_function[:description][:matches] == false
+                      # if the description was removed
+                      if configuration_function[:description].nil?
+                        @generator.remove_function_comment function
+                      else
+                        @generator.set_function_comment function
+                      end
+                    end
+
+                  # If the function exists in both the configuration and database representations
+                  # but the description is different then we need to update the description.
+                  elsif configuration_function[:description][:matches] == false
+                    function = @database.configured_schema(schema_name).function(function_name)
+                    # if the description was removed
+                    if configuration_function[:description].nil?
+                      @generator.remove_function_comment function
+                    else
+                      @generator.set_function_comment function
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dynamic_migrations/postgres/server/database/differences/to_migrations/schemas/tables/columns.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module DynamicMigrations
+  module Postgres
+    class Server
+      class Database
+        class Differences
+          class ToMigrations
+            module Schemas
+              module Tables
+                module Columns
+                  def process_columns schema_name, table_name, configuration_columns, database_columns
+                    # process all the columns
+                    column_names = (configuration_columns.keys + database_columns.keys).uniq
+                    column_names.each do |column_name|
+                      process_column schema_name, table_name, column_name, configuration_columns[column_name] || {}, database_columns[column_name] || {}
+                    end
+                  end
+
+                  def process_column schema_name, table_name, column_name, configuration_column, database_column
+                    # If the column exists in the configuration but not in the database
+                    # then we have to create it.
+                    if configuration_column[:exists] == true && database_column[:exists] == false
+                      # a migration to create the column
+                      column = @database.configured_schema(schema_name).table(table_name).column(column_name)
+                      @generator.add_column column
+
+                    # If the schema exists in the database but not in the configuration
+                    # then we need to delete it.
+                    elsif configuration_column[:exists] == false && database_column[:exists] == true
+                      # a migration to create the column
+                      column = @database.loaded_schema(schema_name).table(table_name).column(column_name)
+                      @generator.remove_column column
+
+                    # If the column exists in both the configuration and database representations
+                    # but the definition (except description, which is handled seeprately below) is different
+                    # then we need to update the definition.
+                    elsif configuration_column.except(:exists, :description).filter { |name, attributes| attributes[:matches] == false }.any?
+                      # update the column
+                      column = @database.configured_schema(schema_name).table(table_name).column(column_name)
+                      @generator.change_column column
+                      # does the description also need to be updated
+                      if configuration_column[:description][:matches] == false
+                        # if the description was removed
+                        if configuration_column[:description].nil?
+                          @generator.remove_column_comment column
+                        else
+                          @generator.set_column_comment column
+                        end
+                      end
+
+                    # If the column exists in both the configuration and database representations
+                    # but the description is different then we need to update the description.
+                    elsif configuration_column[:description][:matches] == false
+                      column = @database.configured_schema(schema_name).table(table_name).column(column_name)
+                      # if the description was removed
+                      if configuration_column[:description].nil?
+                        @generator.remove_column_comment column
+                      else
+                        @generator.set_column_comment column
+                      end
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dynamic_migrations/postgres/server/database/differences/to_migrations/schemas/tables/foreign_key_constraints.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module DynamicMigrations
+  module Postgres
+    class Server
+      class Database
+        class Differences
+          class ToMigrations
+            module Schemas
+              module Tables
+                module ForeignKeyConstraints
+                  def process_foreign_key_constraints schema_name, table_name, configuration_foreign_key_constraints, database_foreign_key_constraints
+                    # process all the foreign_key_constraints
+                    foreign_key_constraint_names = (configuration_foreign_key_constraints.keys + database_foreign_key_constraints.keys).uniq
+                    foreign_key_constraint_names.each do |foreign_key_constraint_name|
+                      process_foreign_key_constraint schema_name, table_name, foreign_key_constraint_name, configuration_foreign_key_constraints[foreign_key_constraint_name] || {}, database_foreign_key_constraints[foreign_key_constraint_name] || {}
+                    end
+                  end
+
+                  def process_foreign_key_constraint schema_name, table_name, foreign_key_constraint_name, configuration_foreign_key_constraint, database_foreign_key_constraint
+                    # If the foreign_key_constraint exists in the configuration but not in the database
+                    # then we have to create it.
+                    if configuration_foreign_key_constraint[:exists] == true && database_foreign_key_constraint[:exists] == false
+                      # a migration to create the foreign_key_constraint
+                      foreign_key_constraint = @database.configured_schema(schema_name).table(table_name).foreign_key_constraint(foreign_key_constraint_name)
+                      @generator.add_foreign_key_constraint foreign_key_constraint
+
+                    # If the schema exists in the database but not in the configuration
+                    # then we need to delete it.
+                    elsif configuration_foreign_key_constraint[:exists] == false && database_foreign_key_constraint[:exists] == true
+                      # a migration to create the foreign_key_constraint
+                      foreign_key_constraint = @database.loaded_schema(schema_name).table(table_name).foreign_key_constraint(foreign_key_constraint_name)
+                      @generator.remove_foreign_key_constraint foreign_key_constraint
+
+                    # If the foreign_key_constraint exists in both the configuration and database representations
+                    # but the definition (except description, which is handled seeprately below) is different
+                    # then we need to update the definition.
+                    elsif configuration_foreign_key_constraint.except(:exists, :description).filter { |name, attributes| attributes[:matches] == false }.any?
+                      # recreate the foreign_key_constraint
+                      original_foreign_key_constraint = @database.loaded_schema(schema_name).table(table_name).foreign_key_constraint(foreign_key_constraint_name)
+                      updated_foreign_key_constraint = @database.configured_schema(schema_name).table(table_name).foreign_key_constraint(foreign_key_constraint_name)
+                      @generator.recreate_foreign_key_constraint original_foreign_key_constraint, updated_foreign_key_constraint
+                      # does the description also need to be updated
+                      if configuration_foreign_key_constraint[:description][:matches] == false
+                        # if the description was removed
+                        if configuration_foreign_key_constraint[:description].nil?
+                          @generator.remove_foreign_key_constraint_comment foreign_key_constraint
+                        else
+                          @generator.set_foreign_key_constraint_comment foreign_key_constraint
+                        end
+                      end
+
+                    # If the foreign_key_constraint exists in both the configuration and database representations
+                    # but the description is different then we need to update the description.
+                    elsif configuration_foreign_key_constraint[:description][:matches] == false
+                      foreign_key_constraint = @database.configured_schema(schema_name).table(table_name).foreign_key_constraint(foreign_key_constraint_name)
+                      # if the description was removed
+                      if configuration_foreign_key_constraint[:description].nil?
+                        @generator.remove_foreign_key_constraint_comment foreign_key_constraint
+                      else
+                        @generator.set_foreign_key_constraint_comment foreign_key_constraint
+                      end
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dynamic_migrations/postgres/server/database/differences/to_migrations/schemas/tables/indexes.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module DynamicMigrations
+  module Postgres
+    class Server
+      class Database
+        class Differences
+          class ToMigrations
+            module Schemas
+              module Tables
+                module Indexes
+                  def process_indexes schema_name, table_name, configuration_indexes, database_indexes
+                    # process all the indexes
+                    index_names = (configuration_indexes.keys + database_indexes.keys).uniq
+                    index_names.each do |index_name|
+                      process_index schema_name, table_name, index_name, configuration_indexes[index_name] || {}, database_indexes[index_name] || {}
+                    end
+                  end
+
+                  def process_index schema_name, table_name, index_name, configuration_index, database_index
+                    # If the index exists in the configuration but not in the database
+                    # then we have to create it.
+                    if configuration_index[:exists] == true && database_index[:exists] == false
+                      # a migration to create the index
+                      index = @database.configured_schema(schema_name).table(table_name).index(index_name)
+                      @generator.add_index index
+
+                    # If the schema exists in the database but not in the configuration
+                    # then we need to delete it.
+                    elsif configuration_index[:exists] == false && database_index[:exists] == true
+                      # a migration to create the index
+                      index = @database.loaded_schema(schema_name).table(table_name).index(index_name)
+                      @generator.remove_index index
+
+                    # If the index exists in both the configuration and database representations
+                    # but the definition (except description, which is handled seeprately below) is different
+                    # then we need to update the definition.
+                    elsif configuration_index.except(:exists, :description).filter { |name, attributes| attributes[:matches] == false }.any?
+                      # rebild the index
+                      original_index = @database.loaded_schema(schema_name).table(table_name).index(index_name)
+                      updated_index = @database.configured_schema(schema_name).table(table_name).index(index_name)
+                      @generator.recreate_index original_index, updated_index
+                      # does the description also need to be updated
+                      if configuration_index[:description][:matches] == false
+                        # if the description was removed
+                        if configuration_index[:description].nil?
+                          @generator.remove_index_comment index
+                        else
+                          @generator.set_index_comment index
+                        end
+                      end
+
+                    # If the index exists in both the configuration and database representations
+                    # but the description is different then we need to update the description.
+                    elsif configuration_index[:description][:matches] == false
+                      index = @database.configured_schema(schema_name).table(table_name).index(index_name)
+                      # if the description was removed
+                      if configuration_index[:description].nil?
+                        @generator.remove_index_comment index
+                      else
+                        @generator.set_index_comment index
+                      end
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end